i have the following code in a .h

@property (nonatomic, copy) NSString *username;

Then, username is assigned in this way when the user enter text in a TextField:

self.username = textField.text;

And then, in dealloc method i call release:

NSLog(@"%d",[username retainCount]);
[username r开发者_如何学Celease];
NSLog(@"%d",[username retainCount]);

But in the console it prints:

2011-01-11 23:09:52.468 IApp[2527:307] 1

2011-01-11 23:09:52.480 IApp[2527:307] 1

What is the problem?

Thanks

After the release, the object is destroyed, so calling 'retaincount' a 2nd time has undefined behavior

What is the problem?

The problem is that you are using retainCount and expecting a meaningful result.

Do not call retainCount

When to use -retainCount?

The above has some good details. So does one of the answers here:

https://stackoverflow.com/questions/4580684/common-programming-mistakes-for-objective-c-developers-to-avoid

Note that you can set the MallocScribble environment variable and this will cause allocated memory to be filled with 0xaa bytes on allocation and 0x55 bytes on deallocation. In the face of that, your second call to retainCount would crash.

The objects are not released immediately. Probably there has to be a run loop cycle before the objects are really released.
However calling retainCount is really a mean thing. Please read why: When to use -retainCount?

EDIT: @kris-van-bael commented on this answer - correctly - that based on the documentation this is not true. So I have to clearly state that what I wrote here is based on testing this issue on iOS simulator - and it's not how it should things work. However it seems that the following code will run without an error:

@interface Test : NSObject { }
@property (retain, nonatomic) NSString *test;
@end

@implementation Test
@synthesize test;
@end

Then somewhere in your code write:

Test* t = [[Test alloc] init];
t.test = @"Test1";

NSLog(@"%@", t.test);

[t release];

t.test = @"Test2";

NSLog(@"%@", t.test);    

This (unfortunatelly) will run with no error on iOS simulator (however executing it step-by-step with the debugger crashes), so there is clearly some trick on deallocating objects in iOS.

When you release the first time, the retain count is 1. Since the memory is about to be deallocated, there is no "need" to decrement the retain count, so the underlying code may simply skip the decrement step and deallocate the memory.

When you peek at the retain count the second time, you are looking at deallocated memory, which is unsafe and could potentially return any value. Since its immediately after the release, the memory probably hasn't been allocated to something else, but you shouldn't be accessing it regardless.