Why should I send -autorelease to my instance variable in my setter method, rather than -release?

Question

Apple is doing this in a setter method for an instance variable mainSprocket:

– (void)setMainSprocket:(Sprocket *)newSprocket {
    [mainSprocket autorelease];
    mainSprocket = [newSprocket retain];
    return;
}

Why do they send -autorelease and not -release? Would a -release have a bad effect here? Actually it should not (for my understanding), because the -release just says that the current object held by the instance variable mainSprocket is no longer used by that instance variable. For the case that anyone else is still interested in exactly that object, that method could retain it, right? So -release should be fine, I think?

Answer 1

They're doing autorelease here in case newSprocket and mainSprocket happen to be the same object. A call to release might inadvertently deallocate the object before it can be retained on the next line, whereas the autorelease won't be processed until the autorelease pool is drained at the end of the event loop.

Consider this scenario:

Sprocket *mySprocket = [Sprocket spacelySprocket];
[sprocketManager setMainSprocket:mySprocket];

Sprocket *anotherPointerToMySprocket = mySprocket;
[sprocketManager setMainSprocket:anotherPointerToMySprocket];

The last line would cause an issue if mainSprocket wasn't autoreleased. Another convention you might sometimes see for setter code that does the same thing is:

– (void)setMainSprocket:(Sprocket *)newSprocket {
    if (newSprocket != mainSprocket) {
        [mainSprocket release];
        mainSprocket = [newSprocket retain];
    }
}

I'll leave it up to others to comment on which is more appropriate or aesthetically pleasing :-)

Answer 2

If mainSprocket and newSprocket were the same object, it could get released if you use a simple release.

If you don't want to use autorelease, use this:

– (void)setMainSprocket:(Sprocket *)newSprocket {
    // if newSprocket and mainSprocket were the same object, 
    // it would first be retained and then released
    // and therefore not deleted.
    [newSprocket retain];
    [mainSprocket release];
    mainSprocket = newSprocket;
    // you don't need return in a void-method
    // return;
}

---

Why aren't you using properties? They are the Objective-C 2.0 way of doing it.

SomeObject.h

@interface SomeObject : NSObject {
    Sprocket *mainSprocket;
}

@property(retain) Sprocket *mainSprocket;

@end

SomeObject.m

@implementation SomeObject

@synthesize mainSprocket;

@end