Question

I’m rather confused about properties and instance variables in Objective-C.

I’m about half-way through Aaron Hillegass’s “Cocoa Programming for Mac OS X” and everything is logical. You would declare a class something like this:

@class Something;

@interface MyClass : NSObject {
    NSString *name;
    NSArray *items;

    Something *something;

    IBOutlet NSTextField *myTextField;
}

@property (nonatomic, retain) NSString *name;
@property (nonatomic, retain) NSArray *items;

• Since other objects need to manipulate our name and items instance variables, we use @property/@synthesize to generate accessors/mutators for them. Within our class, we don’t use the accessors/mutators—we just interact with the instance variable directly.

• something is just an instance variable that we’re going to use in our class, and since no one else needs to use it, we don’t create a pair of accessors and mutators for it.

• We need to interact with a text field in our UI, so we declare an IBOutlet for it, connect it, and we’re done.

All very logical.

However, in the iPhone world, things seem to be different. People declare properties for every single instance variable, declare properties for IBOutlets, and use accessors/mutators to interact with instance variables within the class (e.g. they would write [self setName:@"Test"] rather than name = @"Test").

Why? What is going on? Are these differences iPhone-specific? What are the advantages of declaring properties for all instance variables, declaring properties for IBOutlets, and using accessors/mutators within your own class?

Answer 1

In the iPhone world, there’s no garbage collector available. You’ll have to carefully manage memory with reference counting. With that in mind, consider the difference between:

name = @"Test";

and

self.name = @"Test";
// which is equivalent to:
[self setName: @"Test"];

If you directly set the instance variable, without prior consideration, you’ll lose the reference to the previous value and you can’t adjust its retain count (you should have released it manually). If you access it through a property, it’ll be handled automatically for you, along with incrementing the retain count of the newly assigned object.

The fundamental concept is not iPhone specific but it becomes crucial in an environment without the garbage collector.