Question

I have the following variable defined:

@property (nonatomic, retain) NSMutableArray *arraySpeechSentences;

And I am trying to initialise it in the following way:

// Set the array of sentences to the stored array
NSMutableArray *speechSentences = [[NSMutableArray alloc] initWithArray:[tempDict objectForKey:key]];
arraySpeechSentences = speechSentences;
[speechSentences release];

When I try to call [arraySpeechSentences count] the application crashes. However, if I set the variable in the following way:

// Set the array of sentences to the stored array
NSMutableArray *speechSentences = [[NSMutableArray alloc] initWithArray:[tempDict objectForKey:key]];
self.arraySpeechSentences = speechSentences;
[speechSentences release];

I can call [arraySpeechSentences count] perfectly fine. I was under the impression that if you use self. it simply checks to see if variable is already set, and if so it will release the object before assigning it the new value. Have I got this wrong, and if so when should I be using self. to set values?

Thanks for any help,
Elliott

Answer 1

I’ll try to give a detail answer for this.

First when you use @property/@synthesize directive you create getter and setter methods around a variable.

In your case, the variable is called arraySpeechSentences (the compiler will create the variable for you) and you can access these methods (setters and getters) with self..

self.arraySpeechSentences = // something 

is the same as

[self setArraySpeechSentences:something]; // setter

And

NSMutableArray* something = self.arraySpeechSentences;

is equal to

NSMutableArray* something = [self arraySpeechSentences]; // getter

In the first snippet of code

NSMutableArray *speechSentences = [[NSMutableArray alloc] initWithArray:[tempDict objectForKey:key]];
arraySpeechSentences = speechSentences;

arraySpeechSentences points to the same object speechSentences points to. But when you do [speechSentences release] you dealloc that object and now arraySpeechSentences is a dangling pointer. You receive a message sent to a deallocated instance I suppose. Try to enable Zombie to see it.

Speaking in terms of retain count, the array has a retain count of 1 when you do alloc-init.
But when you release it, the retain count goes to zero, the object doesn’t exist anymore and you have a crash when you try to access arraySpeechSentences.

Instead, when you deal with properties, the policy applied to a variable is important. Since the property use a retain policy, when you set an object

self.arraySpeechSentences = // something

the retain count for the referenced object is increased. Under the hood, saying self.arraySpeechSentences = // something is equal to call the setter like

- (void)setArraySpeechSentences:(NSMutableArray*)newValue
{
    // pseudo code here...
    if(newValue != arraySpeechSentences) {

       [arraySpeechSentences release];
       arraySpeechSentences = [newValue retain]; 
    }
}

The second snippet work since the retain count for your object is one when you do alloc-init, becomes two when you call self.arraySpeechSentences = and returns to one when you do the release. This time, the object is maintained alive since it has a retain count of 1.

If you have a property with a retain or copy policy, don’t forget to release the object in dealloc like, otherwise you can have leaks.

- (void)dealloc
{
    [arraySpeechSentences release];
    [super dealloc];
}

To understand how Memory works I suggest to read MemoryManagement Apple doc.

P.S. Starting from iOS 5 there is a new compiler feature, called ARC (Automatic Reference Counting), that allows you to forget about retain/release calls. In addition, since it forces you to think in terms of object graphs, I suggest you to take a look into.

Hope that helps.