Question

I have an attendant question to iPhone: Why do I need self.<> in viewDidUnload?

Since there is a difference between using self.instance and instance, when is only instance actually used? Just setting the reference to nil seems quite useless? Why is the option there?

Answer 1

Generally, you’ll find a lot of useful information here: http://developer.apple.com/library/ios/#documentation/Cocoa/Conceptual/MemoryMgmt/Articles/mmPractical.html%23//apple_ref/doc/uid/TP40004447-SW4

For the rest of this answer, I’ll assume that you are referring to properties automatically synthesised with the @synthesize directive in your .m files.

Executive summary

When you use the form self.property, retain/release is automatically taken care of for you. When you use the form instanceVariable without the self prefix, you’re on your own with retain/release.

Longer explanation

When you omit the “self.” part, what you really are doing is that you access the automatically generated underlying ivar which the compiler has given the same name as you have given to the property.

If you don’t want the compiler to generate ivars of the same name, then you can use an extended form of the @synthesize directive, like this:

@synthesize myvariable=__myvariable;

That way, you will ask the compiler to create an underlying ivar called __myvariable instead of the default myvariable.

Using this extended form, you would refer to either self.myvariable (as a property) or __myvariable (as an instance variable), which can be handy to visually distinguish the two types of access.

With that in place, we can get to the substance of the matter.

When you use self.myvariable, you implicitly call the accessor methods (possibly synthesised for convenience), like this:

self.myvariable = @"Some string";

is equal to

[self setMyvariable: @"Some string"];

or, in the case of a right hand use of the property

myLocalVar = self.myvariable;

is equal to:

myLocalVar = [self myvariable];

The examples above use the accessor names recommended by Apple.

On the other hand, when you use the instance variable directly, you just assign the variables directly without going through the accessors.

Now, one huge advantage of using the accessors on the iPhone is that the automatically synthesised accessors also take care of the retain/release messages, so you don’t have to worry about that – or waste code lines handling this somewhat tedious stuff.

Since there is no need to worry about retain/release when you are just reading a property, you could argue that you only need to use the property syntax (with self.) on the left side of an assignment, so whether you want to use the self.-syntax on the right hand side of an assignment is partly a matter of style.

Personally, I have developed a style where I try not to refer to automatically synthesised ivars, unless I have specified them in the @synthesize directive. Otherwise Apple might one day change the way an unspecified @synthesize directive works, and my builds would break. But that is just a personal precaution of mine.

There is one exception to all this, as stated in the docs linked at the top of this answer – and that is that you should not use accessors to the class’ own instance variables in the init* methods. One the Mac, you shouldn’t use them in the dealloc methods, either, but this is one point where Apple’s coding recommendations differ between the two platforms.

Ok, this was a long answer to just say, read the docs, but I hope it clarifies things a little. Memory management in reference counted environments is not trivial, so don’t despair if it isn’t clear at first.

PS: And if you think this the sort of worries that others should solve for you, log a bug with Apple to ask for garbage collection on iOS. It works nicely on 64-bit OS X.