iPhone init method issue - iphone

Question

I created a property for the NSArray which creates a getter/setter. I know Apple recommends using the instance variable in the init and dealloc method. I'm trying to figure what to do in the following code.
(1) Do I need an extra release statement? Wouldn't array have a retain count of 2 then 1 with the dealloc, leave a leak. Or would autorelease take care of this?
(2) Is there some way in xCode or instruments to follow a specific variable to see its retain count going through the process.
#property (nonatomic, retain) NSArray *array;
#synthesize arrary = _array;
- (id)initWithNibName:(NSString *)nibNameOrNil
bundle:(NSBundle *)nibBundleOrNil
initWithArray:(NSArray *)array
{
self = [super initWithNibName:nibNameOrNil bundle:nibBundleOrNil];
if (self) {
_array = [[NSArray alloc] initWithArray:array];
}
return self;
}
- (void)dealloc
{
[_array release];
[super dealloc];
}

Answer 1

(1) Do I need an extra release statement? Wouldn't array have a retain count of 2 then 1 with the dealloc, leave a leak. Or would autorelease take care of this?
Let's step through this:
#property (nonatomic, retain) NSArray *array;
// The setter in this case will do the proper ref counting:
#synthesize arrary = _array;
- (id)initWithNibName:(NSString *)nibNameOrNil
bundle:(NSBundle *)nibBundleOrNil
initWithArray:(NSArray *)array
{
self = [super initWithNibName:nibNameOrNil bundle:nibBundleOrNil];
if (self) {
// _array is nil at allocation
_array = [[NSArray alloc] initWithArray:array]; // << self holds one reference
}
return self;
}
- (void)dealloc
{
[_array release]; // << self holds zero references
[super dealloc];
}
In other words, you need nothing more. Personally, I would just use copy in the initializer and for the property (as opposed to retain).
(2) Is there some way in xCode or instruments to follow a specific variable to see its retain count going through the process.
Yes. There are several runtime shortcuts and exceptions to this, however.
The easiest way is to just run instruments with the allocation instrument, then enable reference count recording. It will then record the backtrace and time for every ref count of every individual object.

Answer 2

Your code looks ok to me. You shouldn't have to put an extra release. In your init method, the retain count for _array is 1. After you release in dealloc, you should do _array = nil, to avoid dangling pointers.
To check for leaks you can do either or both of the following:
(i) CMD + Shift + B ---> This runs analyze on your code to spot issues like this.
(ii) Use the "Leaks" and "Allocations" tools in "Instruments". Here you can watch the allocations and leaks (if any) that your application has while executing. It is very useful, and sometimes catches things that "Analyze" doesn't catch.

Answer 3

Edit: Changed to conform to Apple's recommendations. The comments that follow this answer refer to my original (and very bad) version. In future, I will pay proper attention to Practical Memory Management in the iOS Developer Library.
Question (1): No, you don't need an extra release. After [[ASArray alloc] initWithArray:array], your array will have a retain count of 1. In dealloc, the call to [_array release] will return it to 0, and it should be freed.
If [setArray:] is called in the meantime, it will obey its property declaration of retain by retaining the new object and releasing the old one.
If some other object or method retains your array, it is their responsibility to release it. If your array's retainCount is greater than 1 at the start of dealloc, some other object is retaining it, at least temporarily.
Question (2): You can check retainCount at run time, but as the NSObject Protocol Reference warns, it's easy for your object to end up in multiple autorelease pools, making its count meaninglessly high.
Bonus: You may be thinking that [[NSArray alloc] initWithArray:array] will use the retain count of its input and add 1. This only happens if the "copy" is made by retaining and passing a reference to an immutable source, in which case some other object is also retaining a reference to that source. [[NSString alloc] initWithString:] detects if its source is immutable and does this; [[NSArray alloc] initWithArray:] does not. [NSArray copy], on the other hand, will retain and return itself.
These optimizations are of course implementation-specific and should never be assumed. However, it can be educational to construct some objects, avoiding autorelease, and follow their addresses and retainCounts, like this:
NSArray *array1 = [[NSArray alloc] initWithObjects:#"a", nil];
// Do not just assign array1 to [[NSArray alloc] init], or you'll get a singleton empty array with a high retain count.
// Make array1 mutable, and array2 should be copied differently.
NSLog(#"Constructed array1");
NSLog(#"array1 address = %p retainCount = %d", array1, [array1 retainCount]);
NSArray *array2 = [array1 copy];
// Use [[NSArray alloc] initWithArray:] and the results may be different.
NSLog(#"Constructed array2");
NSLog(#"array1 address = %p retainCount = %d", array1, [array1 retainCount]);
NSLog(#"array2 address = %p retainCount = %d", array2, [array2 retainCount]);
[array1 release];
NSLog(#"Released array1");
NSLog(#"array2 address = %p retainCount = %d", array2, [array2 retainCount]);
[array2 release];