Objective-C ARC strong vs retain and weak vs assign

Question

There are two new memory management attributes for properties introduced by ARC  strong and weak   Apart from copy  which is obviously something completely different  are there any differences between strong vs retain and weak vs assign   From my understanding  the only difference here is that weak will assign nil to the pointer  while assign won t  which means the program will crash when I send a message to the pointer once it s been released  But if I use weak  this won t ever happen  because message send to nil won t do anything   I don t know about any differences between strong and retain   Is there any reason why should I use assign and retain in new projects  or are the kind of being deprecated

User · Answer

After reading so many articles Stackoverflow posts and demo applications to check variable property attributes, I decided to put all the attributes information together:

atomic //default
nonatomic
strong=retain //default
weak
retain
assign //default
unsafe_unretained
copy
readonly
readwrite //default

Below is the detailed article link where you can find above mentioned all attributes, that will definitely help you. Many thanks to all the people who give best answers here!!

Variable property attributes or Modifiers in iOS

1.strong (iOS4 = retain )

it says "keep this in the heap until I don't point to it anymore"
in other words " I'am the owner, you cannot dealloc this before aim fine with that same as retain"
You use strong only if you need to retain the object.
By default all instance variables and local variables are strong pointers.
We generally use strong for UIViewControllers (UI item's parents)
strong is used with ARC and it basically helps you , by not having to worry about the retain count of an object. ARC automatically releases it for you when you are done with it.Using the keyword strong means that you own the object.

Example:

@property (strong, nonatomic) ViewController *viewController;

@synthesize viewController;

2.weak -

it says "keep this as long as someone else points to it strongly"
the same thing as assign, no retain or release
A "weak" reference is a reference that you do not retain.
We generally use weak for IBOutlets (UIViewController's Childs).This works because the child object only needs to exist as long as the parent object does.
a weak reference is a reference that does not protect the referenced object from collection by a garbage collector.
Weak is essentially assign, a unretained property. Except the when the object is deallocated the weak pointer is automatically set to nil

Example :

@property (weak, nonatomic) IBOutlet UIButton *myButton;

@synthesize myButton;

Strong & Weak Explanation, Thanks to BJ Homer:

Imagine our object is a dog, and that the dog wants to run away (be deallocated).

Strong pointers are like a leash on the dog. As long as you have the leash attached to the dog, the dog will not run away. If five people attach their leash to one dog, (five strong pointers to one object), then the dog will not run away until all five leashes are detached.

Weak pointers, on the other hand, are like little kids pointing at the dog and saying "Look! A dog!" As long as the dog is still on the leash, the little kids can still see the dog, and they'll still point to it. As soon as all the leashes are detached, though, the dog runs away no matter how many little kids are pointing to it.

As soon as the last strong pointer (leash) no longer points to an object, the object will be deallocated, and all weak pointers will be zeroed out.

When we use weak?

The only time you would want to use weak, is if you wanted to avoid retain cycles (e.g. the parent retains the child and the child retains the parent so neither is ever released).

3.retain = strong

it is retained, old value is released and it is assigned retain specifies the new value should be sent
retain on assignment and the old value sent -release
retain is the same as strong.
apple says if you write retain it will auto converted/work like strong only.
methods like "alloc" include an implicit "retain"

Example:

@property (nonatomic, retain) NSString *name;

@synthesize name;

4.assign

assign is the default and simply performs a variable assignment
assign is a property attribute that tells the compiler how to synthesize the property's setter implementation
I would use assign for C primitive properties and weak for weak references to Objective-C objects.

Example:

@property (nonatomic, assign) NSString *address;

@synthesize address;

User · Answer

The differences between strong and retain    In iOS4  strong is equal to retain It means that you own the object and keep it in the heap until don   t point to it anymore If you write retain it will automatically work just like strong     The differences between weak and assign    A    weak    reference is a reference that you don   t retain and you keep it as long as someone else points to it strongly When the object is    deallocated     the weak pointer is automatically set to nil A  assign  property attribute tells the compiler how to synthesize the property   s setter implementation

User · Answer

To understand Strong and Weak reference consider below example  suppose we have method named as displayLocalVariable    - void displayLocalVariable          NSString myName     ABC        NSLog   My name is        myName         In above method scope of myName variable is limited to displayLocalVariable method  once the method gets finished myName variable which is holding the string  ABC  will get deallocated from the memory     Now what if we want to hold the myName variable value throughout our view controller life cycle  For this we can create the property named as username which will have Strong reference to the variable myName see self username   myName  in below code   as below    interface LoginViewController      property nonatomic strong  NSString  username   property nonatomic weak  NSString  dummyName   -  void displayLocalVariable    end   implementation LoginViewController  -  void viewDidLoad        super viewDidLoad       - void viewWillAppear  BOOL animated         self displayLocalVariable      -  void displayLocalVariable      NSString myName     ABC      NSLog   My name is        myName      self username   myName     -  void didReceiveMemoryWarning        super didReceiveMemoryWarning        end   Now in above code you can see myName has been assigned to self username and self username is having a strong reference as we declared in interface using  property  to myName indirectly it s having Strong reference to  ABC  string   Hence String myName will not get deallocated from memory till self username is alive        Weak reference   Now consider assigning myName to dummyName which is a Weak reference  self dummyName   myName  Unlike Strong reference Weak will hold the myName only till there is Strong reference to myName  See below code to understand Weak reference   - void displayLocalVariable          NSString myName     ABC        NSLog   My name is        myName        self dummyName   myName        In above code there is Weak reference to myName i e  self dummyName is having Weak reference to myName  but there is no Strong reference to myName  hence self dummyName will not be able to hold the myName value   Now again consider the below code   - void displayLocalVariable                  NSString myName     ABC            NSLog   My name is        myName            self username   myName           self dummyName   myName             In above code self username has a Strong reference to myName  hence self dummyName will now have a value of myName even after method ends since myName has a Strong reference associated with it   Now whenever we make a Strong reference to a variable it s retain count get increased by one and the variable will not get deallocated retain count reaches to 0   Hope this helps

User · Answer

Clang s document on Objective-C Automatic Reference Counting  ARC  explains the ownership qualifiers and modifiers clearly      There are four ownership qualifiers            autoreleasing     strong      unsafe unretained      weak         A type is nontrivially ownership-qualified if it is qualified with     autoreleasing    strong  or   weak    Then there are six ownership modifiers for declared property         assign implies    unsafe unretained  ownership     copy implies   strong ownership  as well as the usual behavior of copy semantics on the setter     retain implies   strong ownership     strong implies   strong ownership      unsafe unretained  implies    unsafe unretained  ownership    weak implies   weak ownership           With the exception of weak  these modifiers are available in non-ARC modes    Semantics wise  the ownership qualifiers have different meaning in the five managed operations  Reading  Assignment  Initialization  Destruction and Moving  in which most of times we only care about the difference in Assignment operation        Assignment occurs when evaluating an assignment operator  The   semantics vary based on the qualification          For   strong objects  the new pointee is first retained  second  the lvalue is loaded with primitive semantics  third  the new pointee is stored into the lvalue with primitive semantics  and finally  the old pointee is released  This is not performed atomically  external synchronization must be used to make this safe in the face of concurrent loads and stores     For   weak objects  the lvalue is updated to point to the new pointee  unless the new pointee is an object currently undergoing deallocation  in which case the lvalue is updated to a null pointer  This must execute atomically with respect to other assignments to the object  to reads from the object  and to the final release of the new pointee    For    unsafe unretained  objects  the new pointee is stored into the lvalue using primitive semantics     For   autoreleasing objects  the new pointee is retained  autoreleased  and stored into the lvalue using primitive semantics       The other difference in Reading  Init  Destruction and Moving  please refer to Section 4 2 Semantics in the document

User · Answer

From the Transitioning to ARC Release Notes  the example in the section on property attributes       The following declaration is a synonym for   property retain  MyClass  myObject    property strong  MyClass  myObject    So strong is the same as retain in a property declaration   For ARC projects I would use strong instead of retain  I would use assign for C primitive properties and weak for weak references to Objective-C objects

User · Answer

Strong    Property will not Destroy but Only once you set the property to nil will the object get destroyed By default all instance variables and local variables are strong pointers  You use strong only if you need to retain the object  We generally use strong for UIViewControllers  UI item s parents  IOS 4  non-ARC  We Can Use Retain KeyWord IOS 5 ARC  We Can Use Strong Keyword   Example   property  strong  nonatomic  ViewController  viewController    synthesize viewController   Weak  By Default automatically get and set to nil   We generally use weak for IBOutlets  UIViewController s Childs  and delegate the same thing as assign  no retain or release   Example    property  weak  nonatomic  IBOutlet UIButton  myButton    synthesize myButton

User · Answer

nonatomic atomic   nonatomic is much faster than atomic always use nonatomic unless you have a very specific requirement for atomic  which should be rare  atomic doesn t guarantee thread safety - only stalls accessing the property when it s simultaneously being set by another thread    strong weak assign   use strong to retain objects - although the keyword retain is synonymous  it s best to use strong instead use weak if you only want a pointer to the object without retaining it - useful for avoid retain cycles  ie  delegates  - it will automatically nil out the pointer when the object is released use assign for primatives - exactly like weak except it doesn t nil out the object when released  set by default     Optional   copy   use it for creating a shallow copy of the object good practice to always set immutable properties to copy - because mutable versions can be passed into immutable properties  copy will ensure that you ll always be dealing with an immutable object if an immutable object is passed in  it will retain it - if a mutable object is passed in  it will copy it   readonly   use it to disable setting of the property  prevents code from compiling if there s an infraction  you can change what s delivered by the getter by either changing the variable directly via its instance variable  or within the getter method itself

User · Answer

As far as I know  strong and retain are synonyms  so they do exactly the same   Then the weak is almost like assign  but automatically set to nil after the object  it is pointing to  is deallocated   That means  you can simply replace them   However  there is one special case I ve encountered  where I had to use assign  rather than weak  Let s say we have two properties delegateAssign and delegateWeak  In both is stored our delegate  that is owning us by having the only strong reference  The delegate is deallocating  so our -dealloc method is called too      Our delegate is deallocating and there is no other strong ref  -  void dealloc        delegateWeak doSomething        delegateAssign doSomething       The delegate is already in deallocation process  but still not fully deallocated  The problem is that weak references to him are already nullified  Property delegateWeak contains nil  but delegateAssign contains valid object  with all properties already released and nullified  but still valid       Our delegate is deallocating and there is no other strong ref  -  void dealloc        delegateWeak doSomething      Does nothing  already nil       delegateAssign doSomething      Successful call      It is quite special case  but it reveal us how those weak variables work and when they are nullified

[ios] Objective-C ARC: strong vs retain and weak vs assign

Examples related to ios

Examples related to objective-c

Examples related to ios5

Examples related to properties

Examples related to automatic-ref-counting