Memory leak in iPhone app - iphone

Question

I come from a C background, and as many of you are aware Objective-C is derived from C. I assumed the memory management concepts were similar. I am getting a warning about a potential memory leak however what is strange is that i am releasing the object after an alloc. Take a look at this example:
self.cardCellArray = [[NSMutableArray alloc] initWithCapacity:kTotalNumberOfCards];
and in the dealloc:
- (void) dealloc
{
[super dealloc];
[self.cardCellArray removeAllObjects];
}
The memory leak messages I am getting are:
Method returns an Objective-C object with a +1 retain count
and
Object leaked: allocated object is not referenced later in this execution path and has a retain count of +1
Can anybody spot what I am doing wrong here?

Answer 1

I'm assuming that the cardCellArray property is an owning reference (ie. retain or copy).
self.cardCellArray = [[NSMutableArray alloc] initWithCapacity:kTotalNumberOfCards];
This should be:
self.cardCellArray = [[[NSMutableArray alloc] initWithCapacity:kTotalNumberOfCards] autorelease];
Or even:
cardCellArray = [[NSMutableArray alloc] initWithCapacity:kTotalNumberOfCards];
To ensure the memory management is correct.
Also, the dealloc method should be:
- (void)dealloc
{
[cardCellArray release];
[super dealloc];
}
This assumes that the instance variable for the cardCellArray property is named cardCellArray.

Answer 2

You are not releasing the array but rather just emptying it.
Also note that I moved the [super dealloc] call into the last line, this is because the object with its instance variables gets completely freed later in the dealloc chain and thus you would try to access freed memory.
- (void) dealloc
{
[cardCellArray release];
[super dealloc];
}
Another thing: You are using self.cardCellArray =, depending on how your #property for the ivar looks like, you might have to remove the self. part as it retains the object (or you have to manually release it later). #property's that retain the objects are copy and retain

Answer 3

check if the property cardCellArray is retain or copy. if so, when you are calling self.cardCellArray, the object you set to property cardCellArray get retain count increased by 1.
creating object using alloc & init (such as initWithCapacity:) return a object with retain count 1, because you have called a alloc method here.
While creating object without call alloc such as [NSMutableArray arrayWithCapacity:] will return a autorelease object(it will auto decrease it's retain count by 1 when needed),you can consider it has retain count 0.
in method dealloc, you should call [self.cardCellArray release], this will automatically remove all object the array retain.
Your code here generate a retain-count-1 object after
[[NSMutableArray alloc] initWithCapacity:kTotalNumberOfCards]
and this object's retain count become 2 when you call
self.cardCellArray = xxx
but in dealloc you didn't decrease cardCellArray 's retain count, then leaks occurred.
So Change your code to
self.cardCellArray = [[[NSMutableArray alloc] initWithCapacity:kTotalNumberOfCards] autorelease];
autorelease will automatically decrease retain count when needed.
or self.cardCellArray = [NSMutableArray arrayWithCapacity:kTotalNumberOfCards];
or
NSMutableArray *_array = [[NSMutableArray alloc] initWithCapacity:kTotalNumberOfCards];
self.cardCellArray = _array;
[_array release];
or
cardCellArray = [[NSMutableArray alloc] initWithCapacity:kTotalNumberOfCards];
//this helps because it doesn't call `[self setCardCellArray]` which generate +1 retain count.
finally, remember to release cardCellArray too in dealloc method

Answer 4

Yep, as JustSid suggests you are double-retaining the array and never releasing it.
While Objective-C heap management has it's roots in C, the way individual objects are managed is entirely different.
You don't say how the property cardCellArray is defined, but presumably it's defined as retained, such that, when you assign to self.cardCellArray, you're really executing the method setCardCellArray, and that method "retains" the object. But it's already retained as a result of your alloc call, so now it's retained twice.
Then, in the dealloc method you don't release it at all. You can release the object by doing [cardCellArray release]; or by doing self.cardCellArray = nil;. Either will release it (but only once -- you need to solve your problem with the double retain).
You do not need to do the removeAllObjects call. When you release an object (and the retain count goes to zero) the object's dealloc method is called and it does the releases appropriate for the objects it references.
(And as Sid suggests, do the [super dealloc] call last.)
(But of course, everything above is out the window with ARC, where you get to worry about an entirely new and different set of things you can screw up.)