Question about NSMutableArray, pointers and release

How exactly does the addObject method of NSMutableArray work? Does it create a new instance and add it into the array or does it simply add a reference to the SAME object i开发者_运维技巧nto the array?

If the answer is it only insert a reference to the object, then it leads to my next question:

Let's say I have the following method in one of my class ('list' is a NSMutableArray), gladly, this code works the way I wanted, but i just don't seem to fully understand why:

-(void)buyItem:(Item *)anItem
{
    Item * newItem = [[Item alloc]init];
    newItem.name = anItem.name;
    newItem.details = anItem.details;
    [list addObject:newItem];
    [newItem release];
}

So basically after calling [list addObject:newItem], there would now be total of two reference pointing to the same object right(newItem, and another one in the 'list' array)?

But why does releasing the newItem object here, doesn't wipe out the one in the 'list' NSMutableArray? Aren't they pointing to the same Object?

When you are adding object to NSMutableArray using method addObject: it retains added object. This is why you can release it later and use afterwards by accessing using objectAtIndex: method.

It adds a reference and then increases the objects retain count by one. What you are doing is correct and it will still exist in the array with a retain count of one.

For your reference. What increases an object's retain count?

It's important to understand the distinction between release and dealloc. release simply decrements the "retain count", except that when the count is decremented to zero, release goes on to dealloc the object.

In general (except where documented otherwise), when you pass an object reference (ie, pointer) to an Objective-C object, and it keeps a copy of that reference beyond the duration of your call to it, it retains the object on its own behalf, and it takes the responsibility to release the object when it is itself deallocated, or when the copy of the reference is nullified or overwritten.