iphone - will the retain property propagate on an array?

I have a mutable array that has been retained.

This array contain dictionaries with lots of keys. Each dictionary contains objects.

Do I have to retain the dictionaries before adding them to the mutable array or will the array itself retain everything that is added to it (b开发者_开发知识库ecause it is already retained), including the sub objects of its objects in the hierarchy?

thanks.

A Foundation container, like NSArray or NSDictionary, retains the objects it directly owns, but not subobjects owned by the objects.

For example, if NSArray*a contains NSArray*b and it in turn contains NSArray*c, a retains b and b retains c but a doesn't retain c.

That said, your are thinking from a wrong perspective. It's not correct for you to wonder such as "do I have to retain this object (say x) before passing x to another object y, because y might not retain it appropriately?" The point of retain/release is that to make sure an object retains and releases objects it owns. You trust other objects to do the same.

Then, all you have to make sure if you put an object x to an array y, is for you not to release x (if it's not autoreleased) once it becomes unnecessary to you. If y needs it, y retains it, so you don't have to care about it.

Say you have a pre-existing NSMutableArray*array. Then you would do in a method something like this:

 NSMutableDictionary* dictionary=[[NSMutableDictionary alloc] init];
 ... do something with dictionary ... 
 [array addObject:dictionary];
 [dictionary release];

You see, it's the array's responsibility to retain the dictionary, if that array needs it. It needs it, and so it retains it. You don't have to care about that.

The method's responsibility is to retain the dictionary if the method needs it, to release it if the method no longer needs it. So, as shown above, the method releases it once it's done with it by adding it to the array.

Again: the whole point of retain/release is to allow you to consider the life cycle of an object very locally in the code.

Whenever you call a method method:of another object a by passing an object b, you don't have to worry as you do now whether method: retains b or not, and you don't have to worry if you need to retain b before passing b to method:.

It is because every method in the Cocoa framework, and every method you write, retain the object b passed to it if the method needs it later, and don't retain b if it doesn't need it later.

Objective-C containers (such as NSMutableArray) will retain the objects added to them.

This does not, however, have anything to do with anything being "propagated" -- whether or not you call -retain on the NSMutableArray is irrelevant. The NSMutableArray will simply retain objects added to it, and if those objects are themselves some kind of container (such as a dictionary), the sub-objects will themselves already have retained anything added to them, and so forth.

ps. there isn't really a "retain property", there's an (internal) "retain count" on each object. For example, if you create an NSString and add it to 3 NSMutableArray's, each of those arrays will retain it.