IOS retain , Assign - iphone

Question

I observed the following behavior.
Took two property variables.
#property (nonatomic, retain) NSString *stringOne;
#property (nonatomic, assign) NSString *stringTwo;
In .m file written below code..
NSMutableString *localstring= [[NSMutableString alloc] initWithString:#"test"];
self.stringOne = localstring;
NSLog(#"localstring = %d", [string retainCount]);
NSLog(#"string one retain count = %d", [self.stringOne retainCount]);
self.stringTwo = localstring;
NSLog(#"localstring = %d", [localstring retainCount]);
NSLog(#"string two retain count = %d", [self.stringTwo retainCount]);
Here localstring retain count is 1 because of alloc. Now i gave
self.stringOne = localString.
The retain count of localstring will become two because of retain property of stringOne. Now i gave
self.stringTwo = localString.
Even here the localstring retain count is incremented by one. Notice that i have given assign property to stringTwo. Practically the retain count of localstring or stringTwo should not increase by 1 as it is assign property.
Please correct me if i am wrong.
Thanks
Jithen

Answer 1

Dump the retainCount; it is useless. http://www.whentouseretaincount.com/
The source of your confusion is in not understanding how pointers work. Modify your code like this:
#interface BBQ:NSObject
#property (nonatomic, retain) NSString *stringOne;
#property (nonatomic, assign) NSString *stringTwo;
#end
#implementation BBQ
- (void) burn
{
NSMutableString *localstring= [[NSMutableString alloc] initWithString:#"test"];
self.stringOne = localstring;
NSLog(#"localstring = %p", localstring);
NSLog(#"string one = %p", self.stringOne);
self.stringTwo = localstring;
NSLog(#"localstring = %p", localstring);
NSLog(#"string two = %p", self.stringTwo);
}
#end
It'll spew something like this:
2013-04-11 08:48:13.770 asdffadsfasddfsa[18096:303] localstring = 0x10010aaf0
2013-04-11 08:48:13.772 asdffadsfasddfsa[18096:303] string one = 0x10010aaf0
2013-04-11 08:48:13.772 asdffadsfasddfsa[18096:303] localstring = 0x10010aaf0
2013-04-11 08:48:13.772 asdffadsfasddfsa[18096:303] string two = 0x10010aaf0
There is only one string instance in play; localstring, stringOne, and stringTwo all hold references to exactly one instance of NSMUtableString.
Thus, you'll see +1 RC of that one string instance for the alloc, +1 for the assignment to the stringOne property and no change for stringTwo.
(RC's should only be reasoned about in terms of deltas; if you retain an object, you need to balance that with a release when you no longer need the object. That the object may be retained by something else is irrelevant.)

Answer 2

When I ran this code:
#interface ViewController ()
#property (nonatomic, retain) NSString *stringOne;
#property (nonatomic, assign) NSString *stringTwo;
#end
#implementation ViewController
- (void)viewDidLoad
{
[super viewDidLoad];
[self test];
}
- (void)test
{
NSMutableString *localstring = [[NSMutableString alloc] initWithString:#"test"];
NSLog(#"localstring (before setting `stringOne` or `stringTwo`) = %d", [localstring retainCount]);
self.stringOne = localstring;
NSLog(#"localstring (after setting `stringOne`) = %d", [localstring retainCount]);
NSLog(#"string one retain count = %d", [self.stringOne retainCount]);
self.stringTwo = localstring;
NSLog(#"localstring (after setting `stringTwo`) = %d", [localstring retainCount]);
NSLog(#"string two retain count = %d", [self.stringTwo retainCount]);
}
#end
I received this console log:
localstring (before setting `stringOne` or `stringTwo`) = 1
localstring (after setting `stringOne`) = 2
string one retain count = 2
localstring (after setting `stringTwo`) = 2
string two retain count = 2
And all of those values are precisely as one would expect.
When you first create the object referenced by the local variable, that object has a +1 retain count.
When you set the retain property, stringOne, the object's retain count will be incremented to +2, and as both localstring and stringOne reference that same object, they'll both report the same retainCount.
But when you use the assign property, stringTwo, though, the retainCount does not change.

Answer 3

When you declare a property with retain, it automatically 'retains' the object, thus increasing its retain count.
So NSMutableString *localstring= [[NSMutableString alloc] initWithString:#"test"]; makes retain count = 1;
Then self.stringOne = localstring; makes retain count = 2.
My thinking is if the property is given retain, then after this line
self.stringOne = localstring , the retain count of self.stringone
should become one
When you create an object, it will start with a retain count of 1.

Answer 4

First of all, never use retainCount for anything. It is simply not reliable since it is a global retain count, and can be influenced by other factors outside of your code. Amazingly, in this case, it is correct though. Let's examine:
//Immediately localstring is +1 because you allocated it
NSMutableString *localstring= [[NSMutableString alloc] initWithString:#"test"];
//self.stringOne is a retain property, so localstring is incremented again (+2)
self.stringOne = localstring;
//self.stringTwo is a retain property, so localstring is incremented again (+3)
self.stringTwo = localstring;
Note that now localstring, self.stringOne and self.stringTwo all point to the same location in memory. You are not copying the memory contents every time you use the = sign (your way of thinking seems to indicate that you think that is how it works). You are simply pointing another variable at a location in memory and saying "Don't deallocate this piece of memory until I say so." (at least in the case of retain properties).
Conclusion: localstring's retain count, self.stringOne's retain count, and self.stringTwo's retain count are all the same.
Sidenote: It is impossible for an object to have a retain count of zero. The only time that can happen is when retainCount is sent to nil (which I assume self.stringOne is when you test it)

Answer 5

While it is never a good idea to look at retainCount when writing code, it is behaving as it should in this case. I think your understanding of memory management seems to be a little bit off.
To answer your question,
NSMutableString *localstring= [[NSMutableString alloc] initWithString:#"test"];
This creates a mutable string Object,increments its retain count and returns a pointer to it. Note that retainCount is associated with the Object and not the pointer.
When you assign it to your retain property,
self.stringOne = localstring;
it passes retain to your Object and increments its retain count by 1 again. Now your object's retain count is 2 and both the pointers point to the same object. So, when you log retainCount, you get what you get. Hope this answers your question.