How do you tell whether you need to release an object?

Question

Can you describe the naming convention difference between a method that returns an object it has allocated for the caller (and that the caller should release), and a method that returns an autorelease object?

If you declare a property with a retain attribute, do you need to release the property before you set it to nil?

What does the @synthesize directive do?

Answer 1

memory allocation information and naming can be found here

http://developer.apple.com/library/ios/#documentation/cocoa/Conceptual/ObjectiveC/Articles/ocAllocInit.html

synthesize is documented here

http://developer.apple.com/library/ios/documentation/cocoa/Conceptual/ObjectiveC/Articles/ocProperties.html#//apple_ref/doc/uid/TP30001163-CH17-SW17

The apple website has excellent documentation, I would recommend searching there first.

Answer 2

From apple documentation

You only release or autorelease objects you own. You take ownership of an object if you create it using a method whose name begins with “alloc” or “new” or contains “copy” (for example, alloc, newObject, or mutableCopy), or if you send it a retain message.

You use release or autorelease to relinquish ownership of an object. autorelease just means “send a release message in the future” (to understand when this will be, see “Autorelease Pools”).

Your second two questions are related. All that @synthesize does is to generate additional methods for your implementation file. The arguments to @property (nonatomic, retain) NSString* myString; define the behavior of the generated methods. For example, if you declare a property as retain, the setMyString generated method will retain its argument.

Nonatomic is important because properties, by default, are threadsafe. If you don't need thread safety, you can remove a lot of overhead in your accessor methods.

Finally, the implementation of a retain property is

- (void) setMyString:(NSString*)newString {
    [newString retain];
    [myString release];
    myString = newString;
}

So, saying self.myString = nil effectively releases myString for you. Many people advocate using self.property = nil for retained properties, as opposed to [property release], though I think it just comes down to personal preference.

Answer 3

A good source for memory allocation is listed below by Aaron.

Regarding @synthesize:

Say you have a property P, what you will have to do is write a getter and a setter for it. There are a few common approaches, one of which is that you retain that object when you set that property and release the old value. E.g:

- (void)setP:(PClass *)value
{
  [value retain];
  [_pInstanceVariable release];
  _pInstanceVariable = value;
}

Since this is a very common piece of code, the compiler can automate it for you, if you specify the retain keyword in property declaration and then do the @synthesize in you implementation. The compiler will generate the above mentioned code which means your code will be a lot cleaner without tedious repeating parts.

Same holds true for getters, unless you want something more complex than:

- (PClass *)p
{
  return _pInstanceVariable;
}

the @synthesize will do the job