default setter in iOS

- (void)setSomeInstance:(SomeClass *)aSomeInstanceValue
{
    if (someInstance == aSomeInstanceValue)
{
    return;
}
SomeClass *oldValue = someInstance;
someInstance =开发者_运维问答 [aSomeInstanceValue retain];
[oldValue release];
}

ok, so setter should look like. I understand first 3 lines - prevent before situation when new object is the same as the old one. But what about this line:

SomeClass *oldValue = someInstance;

Why system have to keep address of old object. Why can't it be simply

  [someinstance release];
   someinstance = [aSomeInstanceValue retain];

Actually - no reason.

It's usually just a choice.

There are three idioms for writing accessors.

Autorelease:

- (void)setFoo:(id)newFoo {
    [foo autorelease];
    foo = [newFoo retain];
}

Less code to write, but I think autorelease in this case is being lazy.

Retain then release

- (void)setFoo:(id)newFoo {
    [newFoo retain];
    [foo release];
    foo = newFoo;
}

Check first

- (void)setFoo:(id)newFoo {
    if ([foo isEqual:newFoo]) {
        return;
    }
    [foo release];
    foo = [newFoo retain];
}

The only difference between the last two is that the second checks to see if the new value is different to the current value before trying to set the property. At the cost of an extra if statement. So - if the new value is likely to be the same as the old value, using this construction gives better performance.

Generally, and if you're not using properties for some strange reason, use retain then release, and then if profiling shows that there's a bottleneck - use the check first method.

I would suggest the default retain setter works something like this:

- (void) setFoo:(id) foo {
    if ( foo == _foo) return;
    [_foo release];
    _foo = [foo retain];
}

if you don't check if the old and the new foo are the same, you might end up with a reference to a deallocated object if you for some reason write something like this:

myObject.foo = myObject.foo;

Because the same object would first be released, and then retained. If the myObject is the sole owner, the object would be deallocated after the first release, leaving you with a dangling pointer.

The default retain setter works like that :

- (void)setFoo:(Foo *)aFood
{
    if (_foo != nil)
       [_foo release];
    if (aFood != nil)
       _foo = [aFood retain];
}