Automatic Reference Counting

The following rules are enforced by the compiler when ARC is turned on:

• retain, release, retainCount, autorelease or dealloc cannot be sent to objects. Instead, the compiler inserts these messages at compile time automatically, including [super dealloc] when dealloc is overridden.[9]

  // Without ARC
  - (void)dealloc
  {
     [[NSNotificationCenter defaultCenter] removeObserver:self];
     [super dealloc];
  }
  
  // With ARC
  - (void)dealloc
  {
     [[NSNotificationCenter defaultCenter] removeObserver:self];
     // [super dealloc] is called automatically
  }
  

• Programs cannot cast directly between id and void *.[9] This includes casting between Foundation objects and Core Foundation objects. Programs must use special casts, or calls to special functions, to tell the compiler more information about an object's lifetime.

  // Without ARC
  - (NSString *)giveMeAString
  {
      CFStringRef myString = [self someMethodThatCreatesACFString];
      NSString *newString = (NSString *)myString;
      return [newString autorelease];
  }
  
  // With ARC
  - (NSString *)giveMeAString
  {
      CFStringRef myString = [self someMethodThatCreatesACFString]; // retain count is 1
      NSString *newString = (__bridge_transfer NSString *)myString; // the ownership has now been transferred into ARC
      return newString;
  }
  

• An autorelease pool can be used to allocate objects temporarily and retain them in memory until the pool is "drained". Without ARC, an NSAutoreleasePool object can be created for this purpose. ARC uses @autoreleasepool blocks instead, which encapsulate the allocation of the temporary objects and deallocates them when the end of the block is reached.[9]

  // Without ARC
  - (void)loopThroughArray:(NSArray *)array
  {
      for (id object in array) {
          NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
          // Create a lot of temporary objects
          [pool drain];
      }
  }
  
  // With ARC
  - (void)loopThroughArray:(NSArray *)array
  {
      for (id object in array) {
          @autoreleasepool {
              // Create a lot of temporary objects
          }
      }
  }
  

• Programs cannot call the functions NSAllocateObject and NSDeallocateObject[9]
• Programs cannot use object pointers in C structures (structs)[9]
• Programs cannot use memory zones (NSZone)[9]
• To properly cooperate with non-ARC code, programs must use no method or declared property (unless explicitly choosing a different getter) that starts with new.[9]

In Swift, references to objects are strong, unless they are declared weak or unowned. Swift requires explicit handling of nil with the Optional type: a value type that can either have a value or be nil. An Optional type must be handled by "unwrapping" it with a conditional statement, allowing safe usage of the value, if present. Conversely, any non-Optional type will always have a value and cannot be nil.

var myString: String                   // Can only be a string
var myOtherString: String?             // Can be a string or nil

if let myString = myOtherString {      // Unwrap the Optional
    print(myString)                    // Print the string, if present
}

Accordingly, a strong reference to an object can be of both Optional and non-Optional type (optionality and reference strength are different, albeit related, concepts). A weak reference is always of type Optional, as the object can be deallocated and the reference automatically be set to nil. Unowned references are like weak references but are not set to nil automatically by ARC. They can be either non-Optional or Optional. An unowned reference is expected to always have a value, so accessing the value of an unowned reference after the referenced instance has been deallocated, we result in a runtime error.[11]

var strongReference: MyClass          // Strong non-Optional reference, cannot be nil
var strongOptionalReference: MyClass? // Strong Optional reference, can be nil (manually)
weak var weakReference: MyClass?      // Weak reference, always Optional, can be nil (automatically or manually)
unowned var unownedReference: MyClass // Unowned non-Optional reference, cannot be nil

Swift also differs from Objective-C in its usage and encouragement of value types instead of reference types. Most types in the Swift standard library are value types and they are copied by value, whereas classes and closures are reference types and passed by reference. Because value types are copied when passed around, they are deallocated automatically when the program leaves the scope that contains them.[11][12]

• Smart pointer

• Transitioning to ARC – iOS Developer Library
• "Automatic Reference Counting" in The Swift Programming Language