Question

I’ve read apple documentation to assert that I was doing the memory management correctly but some questions raised.

Question 1:

They exhibit this code snippet as wrong :

in obj implementation:
- (NSString *)method1 {
    NSString *string = [[NSString alloc] initWithFormat:@"%@ %@", firstName, lastName];
    return string;
}

... later ...

NString* myString = [obj method1];
NSLog("%@", myString);
[myString release];

Apple Doc :

You own the string returned by alloc, but lose the reference to it before you get a chance to relinquish ownership. Following the memory management rules, this would result in a memory leak, since the caller has no indication that they own the returned object.

Since I’m taking care of releasing the object that has been allocated previously, there is no memory leak, right ? What do they mean by “lose the reference to it” ?

It is wrong only regarding apple’s memory management recommendations (the caller has no indication that they own the returned object) or this is also technically wrong ?

Question 2 :

This is about autoreleased objects availability :

Example code:

in obj1 implementation:
- (NSString *)methodA {
    NSString *string = [[NSString alloc] initWithFormat:@"%@ %@", firstName, lastName];
    return [string autorelease];
}

in obj2 implementation:
- (NSString *)methodB:(NSString *)inputString {
    NSLog("%@",inputString)
    //*other call of methods with arg inputString*//
}
... later ...

NString* myString = [obj1 methodA];

[obj2 method2:myString];

How far (or deep) following my functions calls will the autorelease object returned by obj1 will be available. Regarding apple’s documentations “Autorelease objects will be available within their variable scope”. Should I retain it at some point ?

Answer 1

Q1: It is wrong only regarding apple’s memory management recommendations (the caller has no indication that they own the returned object) or this is also technically wrong ?

Technically this is correct as you release myString after using it. However if you follow Apples guidelines for method naming (strongly recommended), this is clearly wrong:

You own any object you create.
You “create” an object using a method whose name begins with “alloc” or “new” or contains “copy” (for example, alloc, newObject, or mutableCopy).

method1 doesn’t contain create, alloc, new or copy – thus per the guideline the caller doesn’t own the object and doesn’t have to release it.

Q2: How far (or deep) following my functions calls will the autorelease object returned by obj1 will be available. Regarding apple’s documentations “Autorelease objects will be available within their variable scope”. Should I retain it at some point ?

Auto-released objects will be alive until the closest Autorelease Pool is drained, see Autorelease Pools:

An autorelease pool is an instance of NSAutoreleasePool that “contains” other objects that have received an autorelease message; when the autorelease pool is deallocated it sends a release message to each of those objects. An object can be put into an autorelease pool several times, and receives a release message for each time it was put into the pool. Thus, sending autorelease instead of release to an object extends the lifetime of that object at least until the pool itself is released (the object may survive longer if it is retained in the interim).
…
The Application Kit automatically creates a pool at the beginning of an event cycle (or event-loop iteration), such as a mouse down event, and releases it at the end, so your code normally does not have to worry about them. There are three cases, though, where you might use your own autorelease pools:
…

So, if you need your instances to stay alive after the corresponding autorelease pool was drained, take ownership by retaining them. Otherwise you usually just let them be handled by the pool.