Memory management question (involving arrays)

[kend0g187]

What's the best way to handle the following situation: You have an NSMutableArray property in your controller class. In viewDidLoad(), you load it up with newly-allocated objects. Then later on, you swap out an object for a new one. Something like:

- (void) viewDidLoad {
MyObject *object = [[MyObject alloc] init];
[myArray addObject: object];

- (void) someOtherFunction {
MyObject *newObject = [[MyObject alloc] init];
[myArray replaceObjectAtIndex: 0 withObject: newObject];
}

- (void) dealloc {
[myArray release];
}

The way I got it to work was to use autoreleases anytime I declared a new object, like MyObject *object = [[[MyObject alloc] init] autorelease];, but Instruments says I have a leak.

Also, I tried doing it the following way, and I get EXC_BAD_ACCESS, but I don't understand why:

- (void) viewDidLoad {
MyObject *object = [[MyObject alloc] init];
[myArray addObject: object];

- (void) someOtherFunction {
MyObject *tmp = [myArray objectAtIndex: 0];
MyObject *newObject = [[MyObject alloc] init];
[myArray replaceObjectAtIndex: 0 withObject: newObject];
[tmp release];
}

- (void) dealloc {
for( MyObject* object in myArray ) {
[object release];
}
[myArray release];
}

So basically I have three questions: which way is best? why does the first way (with autoreleases) show leaks? and why does the second way not work?

[baja_yu]

Arrays retain objects added to them and release removed ones. So the first batch looks ok if you were to add autorelease calls to both alloc/inits, or if you called release on object and newObject after you add them to the array.

[VinceYuan]

In a managed memory environment, an object receives a retain message when it’s added; in a garbage collected environment, it is strongly referenced. When an array is deallocated in a managed memory environment, each element is sent a release message.

In a managed memory environment, when an object is removed from a mutable array it receives a release message. If that object is owned only by that array, the object is deallocated when it is removed. If you want to use the object after its removal, you should therefore typically send it a retain message before it’s removed from the array.

- (void) viewDidLoad {
MyObject *object = [[MyObject alloc] init];
[myArray addObject: object]; //myArray retains object
[object release];
}

- (void) someOtherFunction {
MyObject *newObject = [[MyObject alloc] init];
[myArray replaceObjectAtIndex: 0 withObject: newObject];
[newObject release];
}

- (void) dealloc {
[myArray release];
}

[Duncan C]

Originally Posted by kend0g187

What's the best way to handle the following situation: You have an NSMutableArray property in your controller class. In viewDidLoad(), you load it up with newly-allocated objects. Then later on, you swap out an object for a new one. Something like:

- (void) viewDidLoad {
MyObject *object = [[MyObject alloc] init];
[myArray addObject: object];

- (void) someOtherFunction {
MyObject *newObject = [[MyObject alloc] init];
[myArray replaceObjectAtIndex: 0 withObject: newObject];
}

- (void) dealloc {
[myArray release];
}

The way I got it to work was to use autoreleases anytime I declared a new object, like MyObject *object = [[[MyObject alloc] init] autorelease];, but Instruments says I have a leak.

Also, I tried doing it the following way, and I get EXC_BAD_ACCESS, but I don't understand why:

- (void) viewDidLoad {
MyObject *object = [[MyObject alloc] init];
[myArray addObject: object];

- (void) someOtherFunction {
MyObject *tmp = [myArray objectAtIndex: 0];
MyObject *newObject = [[MyObject alloc] init];
[myArray replaceObjectAtIndex: 0 withObject: newObject];
[tmp release];
}

- (void) dealloc {
for( MyObject* object in myArray ) {
[object release];
}
[myArray release];
}

So basically I have three questions: which way is best? why does the first way (with autoreleases) show leaks? and why does the second way not work?

Your first block of code is really close. You just need to fix it like this:

- (void) viewDidLoad {
MyObject *object = [[[MyObject alloc] init] autorelease];
[myArray addObject: object];

- (void) someOtherFunction {
MyObject *newObject = [[[MyObject alloc] init] autorelease];
[myArray replaceObjectAtIndex: 0 withObject: newObject];
}

- (void) dealloc {
[myArray release];
}

You just need the autoreleases I added.

As Baya said, arrays retain objects that are added to them, and release objects when they are removed. So if you add an autoreleased object to an array, it sticks around as long as it is in the array, and gets released as soon as you remove it from the array.

Your first block of code was creating objects with alloc/init. Objects created with alloc/init have a retain count of 1, and it is your job to release them when you are done with them. You then add them to your array, which causes them to have a retain count of 2. When you remove them from the array, their retain count drops to 1, so they don't get deallocated.

I'm not sure why your second try is crashing, but what you are doing is a band-aid to fix the original problem.

[kend0g187]

Well, I actually got both ways working, so it must have been something else that was causing the EXC_BAD_ACCESS. But I have another question. Say the MyObject class has an object as one of it's properties, something like:

@interface MyObject : NSObject {
	UIImageView *imageView;
}

@implementation MyObject
@synthesize imageView;
- (void) dealloc {
	[imageView release];
	[super dealloc];
}

It appears as though, when you send a release to a MyObject, the release IS NOT sent to imageView, so the following code causes a leak:

- (void)viewDidLoad {
MyObject *object = [[MyObject alloc] init];
object.imageView = [[UIImageView alloc] init];
[myArray addObject: object];
}
- (void)dealloc {
	for( MyObject *object in myArray ) {
		[object release];
	}
[myArray release];
}

After the object is loaded into the array, object and object.imageView both have a retain count of 2. When dealloc is called, the for loop decrements object to 1, but object.imageView is still at 2. Then when the array releases, object goes to 0 and the MyObject dealloc method gets called taking object.imageView down to 1, not 0. What's the solution?

[baja_yu]

1. Define a retainer property for your imageView in the header file. @property (nonatomic, retain) UIImageView *imageView;
2. In viewDidLoad you need to release (or autorelease) the new MyObject and UIImageView or you will be leaking them both.
3. Again, you do not need to loop and release objects in an array. When you send release to an array it will automatically send release to each of its objects.

4. Read this, it will make things much more clear: http://www.iphonedevsdk.com/forum/ip...roperties.html