Assign And Weak

Question

I want to look a difference between assign and weak.So I run this code below:

@interface Test : NSObject

@property(nonatomic, strong) NSString *str;
@property(nonatomic, assign) NSString *assignString;
@property(nonatomic, weak)   NSString *weakString;

@end

@implementation Test

- (id)init
{
    self =[super init];
    if (self)
    {
        self.str = @"i'm test string";
        
        self.assignString = self.str;
        self.weakString = self.str;

        self.str = nil;
        
        NSLog(@"dealloc \nstr = %p\n assignstr = %p\n weakStr = %p\n", self.str, self.assignString, self.weakString);

        NSLog(@"str = %@ \nassignStr = %@\n weakString = %@\n", self.str, self.assignString, self.weakString);
    }
    
    return self;
}

@end

I think it should output like this:

str = 0x0

assignString = 0x0

weakString = 0x0

str = (null)

assignString = (null)

weakString = (null)

But I get this output:

2015-06-17 11:22:04.676 AssignWeakDiff[4696:1897735]

str = 0x0

assignstr = 0x100002078

weakStr = 0x100002078

str = (null)

assignStr = i'm test string

weakString = i'm test string

It's there something wrong with my code?

Try exploring with something other than literal strings, you have no control over their lifetime. — CRD, Jun 17 '15 at 04:07
A simple change to bypass the string literal is `self.str = [@"hello" mutableCopy]`. — rob mayoff, Jun 17 '15 at 04:58

score 4 · Accepted Answer · answered Jun 17 '15 at 04:55

As CRD said, strings have all sorts of optimizations that alter their memory management. Repeat this exercise with your own custom NSObject subclass and you should see traditional object lifecycle behaviors.
Your expected output for the assign property is incorrect. You should expect that to have a dangling pointer to the deallocated object. The assign reference is not set to nil automatically when the object is deallocated. The weak reference will, but the assign reference will not.

Thus, if you have properties like so:

@property (nonatomic, strong) MyObject *strongObj;
@property (nonatomic, assign) MyObject *assignObj;
@property (nonatomic, weak)   MyObject *weakObj;

And then do:

self.strongObj = [[MyObject alloc] init];
self.assignObj = self.strongObj;
self.weakObj   = self.strongObj;

NSLog(@"%@ %@ %@", self.strongObj, self.assignObj, self.weakObj);

self.strongObj = nil;

NSLog(@"%@ %@ %@", self.strongObj, self.assignObj, self.weakObj);

At the second NSLog statement, the strong and weak references will be nil, but the assign reference will not.

Thank you for your answer, I also repeat this exercise with NSArray, and the console output the same result as NSString. Ok , I will try it with my custom class. thank you very much!! — chengwen.Y, Jun 17 '15 at 05:51
@chengwen.Y By the way, make sure you use the `alloc`/`init` pattern (which will not create `autorelease` object) not the convenience factory methods. If you used array and instantiated it with a convenience method, you might have ended up with `autorelease` object, that might not be deallocated until the pool is drained. — Rob, Jun 17 '15 at 05:58

Assign And Weak

1 Answers1