Correct use of autorelease

Question

I am trying to understand why my application crashes and I am going through my code. I am pretty sure that this is a valid use of autorelease:

(part of the code)

- (NSArray *)allQuestionsFromCategories:(NSArray *)categories {

    ...

    NSMutableArray *ids = [[[NSMutableArray alloc] init] autorelease];

    while (sqlite3_step(statement) == SQLITE_ROW) {
        [ids addObject:[NSNumber numberWithInt:sqlite3_column_int(statement, 0)]];
    }

    return [NSArray arrayWithArray:ids];
}

Is this valid? The NSArray arrayWithArray returns an autorelease object doesn't it? I also have some difficulties in understanding the scope of autoreleased objects. Would the autoreleased object (if it is in this case) be retained by the pool through out the method that invoked the method that this code is a part of?

- (void)codeThatInvokesTheCodeAbove {
    NSArray *array = [self.dao allQuestionsFromCategories];
    ...
}

Would the array returned be valid in the whole codeThatInvokesTheCodeAbove method without retaining it? And if it was, would it be valid even longer?

Got some issues understanding the scope of it, and when I should retain an autorelease object.

Answer 1

That is valid, but -- really -- you can just skip the [NSArray arrayWithArray:ids]; entirely as there is no need to create a new array.

An autoreleased object is valid until the autorelease pool is drained, which typically happens once per pass through a run loop (or "periodically, but never while your block is executing" when enqueuing stuff via GCD).

The documentation explains it all better than I.

---

There is no need to create an immutable array because the return will effectively "up cast" the NSMutableArray to NSArray. While this is meaningless at run time, it means that the caller cannot compile a call to a mutating method of the returned value without using a cast to avoid the warning. Casting to avoid warnings in this context is the epitome of evil and no competent developer would do that.

If it were an instance variable being returned then, yes, creating an immutable copy is critical to avoid subsequent mutations "escaping" unexpectedly.

Have you read the memory management documentation? Specifically, the part about autorelease pools? It makes it quite clear how autorelease works. I hate to paraphrase a definitive work.

Answer 2

[NSArray arrayWithArray:] returns an autoreleased object. If you want codeThatInvokesTheCodeAbove to take ownership of the array, you should call retain on it (and rename codeThatInvokesTheCodeAbove according to apple's guidelines). Otherwise, if you don't care that ownership of the object is ambiguous then your code is okay.

In other words, [NSArray arrayWithArray:] returns an array that you don't own, but you have access to it for at least this run cycle. Therefore, codeThatInvokesTheCodeAbove will have access to it for at least this run cycle. Ownership is not clear, since nobody called alloc, copy, new, or mutableCopy or retain. It is implied that NSArray called autorelease before returning the new array, thus relinquishing ownership.

My information comes from http://developer.apple.com/library/mac/#documentation/Cocoa/Conceptual/MemoryMgmt/Articles/mmRules.html%23//apple_ref/doc/uid/20000994-BAJHFBGH.

So, to answer your question, yes your posted code is valid. Whether it's correct depends on what it is you are trying to accomplish.

Answer 3

Autoreleased object are objects that are marked as to be release later. There is a very particular object that is automatically created by UIApplicationMain: an UIRunLoop. Imagine it like a while structure, it cycle until application is terminate, it receives every event and properly resend it to your interested classes, for example. Just before UIApplicationMain there is a command to create an NSAutoreleasePool that, once the NSRunLoop is ready, attach to it. When you send an -autorelease command to an object, the NSAutoreleasePool will remember to release it when is released itself. It's dangerous to use it many times in platforms that has less memory (iOS devices), because objects aren't released when you send an -autorelease command but when the NSAutoreleasePool is drained (when app releases it).

Answer 4

If you want to free the non-mutable list before you return, you can use something like this:

 - (NSArray *)allQuestionsFromCategories:(NSArray *)categories {

    ...

    NSArray* result;
    NSMutableArray *ids = [[NSMutableArray alloc] init]; // AUTORELEASE REMOVED FROM HERE


    while (sqlite3_step(statement) == SQLITE_ROW) {
        [ids addObject:[NSNumber numberWithInt:sqlite3_column_int(statement, 0)]];
    }
    result = [NSArray arrayWithArray:ids]; // COPY LIST BEFORE IT IS FREED.
    [ids release]; // MUTABLE LIST FREES _NOW_

    return result; // NONMUTABLE COPY IS RETURNED
}

It is not worth doing this unless your mutable array is likely to sometimes use a lot of memory.