Question

I have read that dealloc for an object will be called, only if retain count of that object becomes zero.

I am taking one object for UIColor in interface section and setting property

UIColor *currentColor;
@property (nonatomic, retain) UIColor *currentColor;

After using this object in the implemetation section, I am calling release method for this object in dealloc

-(void)dealloc
{
    [currentColor release];
    [super dealloc];
}

I am in doubt how dealloc will be called for this object, because I am not releasing the retained object anywhere. Thanks in advance.

Answer 1

I have read that dealloc for an object will be called, only if retain
count of that object becomes zero.

Yes.

For the sake of simplicity, call the class that contains currentColor object as ColorContainer. Now, if you create an instance of ColorContainer like the following:

ColorContainer* containerColor = [[ColorContainer alloc] init]; // retain count + 1

the retain count for containerColor becomes 1.

Suppose you create an instance of a UIColor and you set that instance to currentColor property. In this case you can follow two different ways.
In the first one you can create an instance like the following. If you use an instance method like initWithRed:green:blue:alpha: you have to release memory explicitly.

UIColor color* = [[UIColor alloc] initWithRed:0 green:0 blue:0 alpha:1]; // retain count + 1
containerColor.currentColor = color; // retain count +1, the referenced object has a retain count of 2 because you use a retain policy
[color release]; // retain count -1, now  the referenced object has a retain count of 1

In the second way, instead, you could use a class method (+ symbol). In this case you don’t need to release memory explicity because the object created in that class method will be autoreleased at a certain point of your application lifetime.

containerColor.currentColor = [UIColor whiteColor]; // retain count +1

Now suppose you release containerColor object. If the retain count for containerColor is equal to 1, releasing it from an object that uses it, it enables to call its dealloc method and, in consequence, to dismiss also the object referenced by currentColor.

In this simple case study you have to note that the object referenced by currentColor is completely removed from memory (dismissed) only if it has a retain count of 1. In fact, if you do this

UIColor color* = [[UIColor alloc] initWithRed:0 green:0 blue:0 alpha:1]; // retain count + 1
containerColor.currentColor = color; // retain count +1, the referenced object has a retain count of 2
//[color release];

you create a memory leak (Do you understand way?).

To summarize, when you use retain, copy, init or new (it’s the same of alloc-init), you have always to call their counterparts release or autorelease.

As a rule of thumb, you need always to balance the retain count for objects to avoid memory leaks.

So, as a methaphor you could think to memory like a tree. Suppose you have a parent (containerColor) and a child (currentColor). If the parent (with a retain of count of 1) is released, it causes to call its dealloc method and free memory for its object. If in its dealloc method you release a child (with a retain count of 1) it causes to call its dealloc method and free memory. In the case a child has a retain count greater than one, you cause a memory leak.

Hope it helps.

Edit

For further information you could read About Memory Management. Since iOS 5 Apple has introduced ARC. Automatic Reference Counting is a compiler machanism that provides automatic memory management of Objective-C objects. For info see Transitioning to ARC Release Notes.