Objective-C ARC Patterns

Introduction

Automatic Reference Counting (ARC) is Objective-C's memory management system that automatically inserts retain and release calls at compile time. ARC eliminates most manual memory management while providing deterministic memory behavior and preventing common memory bugs like use-after-free and double-free.

Unlike garbage collection, ARC provides immediate deallocation when reference counts reach zero, making it suitable for resource-constrained environments like iOS. Understanding ARC's ownership rules, qualifiers, and patterns is essential for writing memory-safe Objective-C code and avoiding retain cycles.

This skill covers strong and weak references, ownership qualifiers, retain cycles, Core Foundation bridging, and best practices for ARC-based memory management.

Strong and Weak References

Strong references maintain ownership of objects and prevent deallocation, while weak references observe objects without preventing deallocation.

// Strong references (default)
@interface Person : NSObject
@property (nonatomic, strong) NSString *name;
@property (nonatomic, strong) NSArray *friends;
@property (nonatomic, strong) UIImage *photo;
@end

@implementation Person
@end

// Weak references
@interface ViewController : UIViewController
@property (nonatomic, weak) id<ViewControllerDelegate> delegate;
@property (nonatomic, weak) IBOutlet UILabel *nameLabel;
@end

@implementation ViewController
@end

@protocol ViewControllerDelegate <NSObject>
- (void)viewControllerDidFinish:(ViewController *)controller;
@end

// Using strong and weak
void strongWeakExample(void) {
    Person *person = [[Person alloc] init];
    person.name = @"Alice"; // Strong reference to NSString

    __weak Person *weakPerson = person; // Weak reference
    NSLog(@"Weak person: %@", weakPerson.name);

    person = nil; // Person deallocated
    NSLog(@"After nil: %@", weakPerson); // weakPerson is now nil
}

// Unowned references (unsafe_unretained)
@interface NodeOld : NSObject
@property (nonatomic, unsafe_unretained) NodeOld *parent;
@property (nonatomic, strong) NSArray<NodeOld *> *children;
@end

@implementation NodeOld
@end

// Weak vs unowned
@interface CommentOld : NSObject
@property (nonatomic, strong) NSString *text;
@property (nonatomic, weak) PostOld *post; // Weak: can be nil
@end

@interface PostOld : NSObject
@property (nonatomic, strong) NSArray<CommentOld *> *comments;
@end

@implementation CommentOld
@end

@implementation PostOld
@end

// Strong captures in blocks
void blockCaptureExample(void) {
    Person *person = [[Person alloc] init];
    person.name = @"Bob";

    // Strong capture
    void (^strongBlock)(void) = ^{
        NSLog(@"%@", person.name); // Captures person strongly
    };

    // Weak capture to avoid retain cycle
    __weak Person *weakPerson = person;
    void (^weakBlock)(void) = ^{
        NSLog(@"%@", weakPerson.name); // Captures weakly
    };

    strongBlock();
    weakBlock();
}

Strong references increment retain count, while weak references are automatically set to nil when the object deallocates, preventing dangling pointers.

Retain Cycles and Breaking Them

Retain cycles occur when objects hold strong references to each other, preventing deallocation. Breaking cycles requires weak or unowned references.

// Retain cycle example
@interface Parent : NSObject
@property (nonatomic, strong) NSArray<Child *> *children;
@end

@interface Child : NSObject
@property (nonatomic, weak) Parent *parent; // Weak to break cycle
@property (nonatomic, strong) NSString *name;
@end

@implementation Parent
- (void)dealloc {
    NSLog(@"Parent deallocated");
}
@end

@implementation Child
- (void)dealloc {
    NSLog(@"Child deallocated");
}
@end

void noCycleExample(void) {
    Parent *parent = [[Parent alloc] init];
    Child *child = [[Child alloc] init];
    child.name = @"Alice";
    child.parent = parent; // Weak reference

    parent.children = @[child]; // Strong reference
    // When parent goes out of scope, both deallocate
}

// Delegate pattern without cycles
@protocol DataSourceDelegate <NSObject>
- (void)dataSourceDidUpdate:(id)source;
@end

@interface DataSource : NSObject
@property (nonatomic, weak) id<DataSourceDelegate> delegate;
- (void)fetchData;
@end

@implementation DataSource
- (void)fetchData {
    // Fetch data
    [self.delegate dataSourceDidUpdate:self];
}

- (void)dealloc {
    NSLog(@"DataSource deallocated");
}
@end

// Block retain cycles
@interface NetworkManager : NSObject
@property (nonatomic, strong) NSString *baseURL;
- (void)fetchDataWithCompletion:(void (^)(NSData *data))completion;
@end

@implementation NetworkManager
- (void)fetchDataWithCompletion:(void (^)(NSData *))completion {
    // Simulate async work
    dispatch_async(dispatch_get_global_queue(
        DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        NSData *data = [@"response" dataUsingEncoding:NSUTF8StringEncoding];
        dispatch_async(dispatch_get_main_queue(), ^{
            completion(data);
        });
    });
}

- (void)dealloc {
    NSLog(@"NetworkManager deallocated");
}
@end

// Avoiding block cycles with weak-strong dance
@interface ViewController2 : UIViewController
@property (nonatomic, strong) NetworkManager *networkManager;
@end

@implementation ViewController2
- (void)loadData {
    __weak typeof(self) weakSelf = self;
    [self.networkManager fetchDataWithCompletion:^(NSData *data) {
        __strong typeof(weakSelf) strongSelf = weakSelf;
        if (!strongSelf) return;

        // Use strongSelf safely
        NSLog(@"Data loaded: %@", strongSelf.view);
    }];
}

- (void)dealloc {
    NSLog(@"ViewController2 deallocated");
}
@end

// Observer pattern cycles
@interface Observable : NSObject
@property (nonatomic, strong) NSMutableArray *observers;
- (void)addObserver:(id)observer;
- (void)removeObserver:(id)observer;
- (void)notifyObservers;
@end

@implementation Observable
- (instancetype)init {
    self = [super init];
    if (self) {
        _observers = [NSMutableArray array];
    }
    return self;
}

- (void)addObserver:(id)observer {
    // Use NSPointerArray for weak references
    [self.observers addObject:[NSValue valueWithPointer:(__bridge void *)observer]];
}

- (void)removeObserver:(id)observer {
    [self.observers removeObject:[NSValue valueWithPointer:(__bridge void *)observer]];
}

- (void)notifyObservers {
    for (NSValue *value in self.observers) {
        id observer = (__bridge id)(void *)[value pointerValue];
        if (observer) {
            // Notify observer
        }
    }
}
@end

Always use weak references for delegates, parent pointers, and observers to break retain cycles. Use the weak-strong dance in blocks for safe self access.

Ownership Qualifiers

ARC provides ownership qualifiers that explicitly control memory management behavior for variables and properties.

// Property ownership qualifiers
@interface Container : NSObject

// Strong: default for object pointers
@property (nonatomic, strong) id strongProperty;

// Weak: doesn't prevent deallocation
@property (nonatomic, weak) id weakProperty;

// Copy: creates a copy of the object
@property (nonatomic, copy) NSString *name;
@property (nonatomic, copy) NSArray *items;

// Assign: for non-object types
@property (nonatomic, assign) NSInteger count;
@property (nonatomic, assign) CGFloat value;

// Unsafe_unretained: weak without nil-ing
@property (nonatomic, unsafe_unretained) id unsafeProperty;

@end

@implementation Container
@end

// Variable qualifiers
void qualifierExamples(void) {
    // __strong: default qualifier
    __strong NSString *strongString = @"Hello";

    // __weak: weak reference
    __weak NSString *weakString = strongString;

    // __unsafe_unretained: unmanaged weak
    __unsafe_unretained NSString *unsafeString = strongString;

    // __autoreleasing: for out parameters
    NSError * __autoreleasing error;
}

// Copy property behavior
@interface Message : NSObject
@property (nonatomic, copy) NSString *text;
@property (nonatomic, copy) NSArray *recipients;
@end

@implementation Message
@end

void copyPropertyExample(void) {
    Message *message = [[Message alloc] init];

    NSMutableString *mutableText = [NSMutableString stringWithString:@"Hello"];
    message.text = mutableText; // Copy made

    [mutableText appendString:@" World"];
    NSLog(@"Message text: %@", message.text); // Still "Hello"
    NSLog(@"Mutable text: %@", mutableText); // "Hello World"
}

// Autoreleasing parameters
BOOL loadData(NSData **outData, NSError **outError) {
    if (outData) {
        *outData = [@"data" dataUsingEncoding:NSUTF8StringEncoding];
    }
    return YES;
}

void autoreleaseExample(void) {
    NSData *data;
    NSError *error;

    if (loadData(&data, &error)) {
        NSLog(@"Loaded: %@", data);
    } else {
        NSLog(@"Error: %@", error);
    }
}

// Property attribute combinations
@interface ConfiguredObject : NSObject

// Read-only strong
@property (nonatomic, strong, readonly) NSString *identifier;

// Read-write copy
@property (nonatomic, copy, readwrite) NSString *name;

// Weak nullable
@property (nonatomic, weak, nullable) id<NSObject> delegate;

// Strong nonnull
@property (nonatomic, strong, nonnull) NSArray *items;

@end

@implementation ConfiguredObject
@end

Choose copy for properties that accept mutable types like NSMutableString or NSMutableArray to prevent unexpected mutations.

Core Foundation Bridging

Core Foundation objects require explicit memory management and bridging to work correctly with ARC-managed Objective-C objects.

// Toll-free bridging with __bridge
void bridgingExample(void) {
    NSString *nsString = @"Hello";

    // Bridge to CF without transfer
    CFStringRef cfString = (__bridge CFStringRef)nsString;
    // nsString retains ownership

    // Bridge back to NS
    NSString *nsString2 = (__bridge NSString *)cfString;
}

// Transferring ownership to CF
void bridgeRetainExample(void) {
    NSString *nsString = @"Hello";

    // Transfer ownership to CF
    CFStringRef cfString = (__bridge_retained CFStringRef)nsString;
    // Must manually CFRelease

    // Use cfString
    CFIndex length = CFStringGetLength(cfString);
    NSLog(@"Length: %ld", (long)length);

    // Release manually
    CFRelease(cfString);
}

// Transferring ownership from CF
void bridgeTransferExample(void) {
    // Create CF object (owned)
    CFMutableStringRef cfString = CFStringCreateMutable(NULL, 0);
    CFStringAppend(cfString, CFSTR("Hello"));

    // Transfer to ARC
    NSMutableString *nsString = (__bridge_transfer NSMutableString *)cfString;
    // ARC now owns, no CFRelease needed

    [nsString appendString:@" World"];
    NSLog(@"%@", nsString);
}

// Working with CF collections
void cfCollectionExample(void) {
    // Create CF array
    CFArrayRef cfArray = CFArrayCreate(
        NULL,
        (const void *[]){@"A", @"B", @"C"},
        3,
        &kCFTypeArrayCallBacks
    );

    // Bridge to NSArray
    NSArray *nsArray = (__bridge_transfer NSArray *)cfArray;
    NSLog(@"Array: %@", nsArray);
}

// CF property lists
void cfPropertyListExample(void) {
    NSDictionary *dict = @{@"key": @"value"};

    // Convert to CF
    CFPropertyListRef plist = (__bridge_retained CFPropertyListRef)dict;

    // Write to file
    CFURLRef url = (__bridge CFURLRef)[NSURL fileURLWithPath:@"/tmp/test.plist"];
    CFPropertyListWrite(plist, url, kCFPropertyListXMLFormat_v1_0, 0, NULL);

    CFRelease(plist);
}

// Handling CF callbacks
void myCFArrayApplierFunction(const void *value, void *context) {
    NSString *string = (__bridge NSString *)value;
    NSLog(@"Value: %@", string);
}

void cfCallbackExample(void) {
    CFArrayRef cfArray = (__bridge CFArrayRef)@[@"A", @"B", @"C"];

    CFArrayApplyFunction(
        cfArray,
        CFRangeMake(0, CFArrayGetCount(cfArray)),
        myCFArrayApplierFunction,
        NULL
    );
}

Use __bridge for temporary bridging, __bridge_retained when transferring to CF, and __bridge_transfer when transferring from CF to ARC.

ARC and C Structures

When mixing ARC objects with C structures, explicit memory management is required for object pointers in structures.

// Struct with object pointers
typedef struct {
    __unsafe_unretained NSString *name;
    NSInteger age;
} PersonStruct;

void structExample(void) {
    PersonStruct person;
    person.name = @"Alice"; // Must use __unsafe_unretained
    person.age = 30;

    NSLog(@"Person: %@, %ld", person.name, (long)person.age);
}

// Better: Use Objective-C class instead
@interface PersonData : NSObject
@property (nonatomic, strong) NSString *name;
@property (nonatomic, assign) NSInteger age;
@end

@implementation PersonData
@end

// Struct with manual memory management
typedef struct PersonStructManual {
    CFStringRef name; // Use CF types for retained ownership
    NSInteger age;
} PersonStructManual;

PersonStructManual createPerson(NSString *name, NSInteger age) {
    PersonStructManual person;
    person.name = CFBridgingRetain(name); // Retain manually
    person.age = age;
    return person;
}

void releasePerson(PersonStructManual person) {
    CFRelease(person.name); // Release manually
}

void manualStructExample(void) {
    PersonStructManual person = createPerson(@"Bob", 25);
    // Use person
    releasePerson(person);
}

// Arrays of objects in structs
typedef struct {
    __unsafe_unretained NSArray *items;
    NSInteger count;
} ContainerStruct;

// Alternative: Use pointer to object
typedef struct {
    void *items; // Bridge to NSArray when needed
    NSInteger count;
} ContainerStructPointer;

void pointerStructExample(void) {
    NSArray *array = @[@1, @2, @3];

    ContainerStructPointer container;
    container.items = (__bridge void *)array;
    container.count = array.count;

    // Retrieve
    NSArray *retrieved = (__bridge NSArray *)container.items;
    NSLog(@"Items: %@", retrieved);
}

Avoid storing ARC-managed objects in C structures. Use Objective-C classes or CF types with manual management instead.

Autorelease Pools

Autorelease pools manage temporary objects created by convenience methods and prevent memory buildup in loops.

// Implicit autorelease pool in main
int main(int argc, char *argv[]) {
    @autoreleasepool {
        return UIApplicationMain(argc, argv, nil,
            NSStringFromClass([AppDelegate class]));
    }
}

// Explicit autorelease pools in loops
void processLargeDataset(void) {
    NSArray *items = /* large array */;

    for (id item in items) {
        @autoreleasepool {
            // Temporary objects released each iteration
            NSString *processed = [item description];
            NSData *data = [processed dataUsingEncoding:NSUTF8StringEncoding];
            // data and processed released at end of iteration
        }
    }
}

// Without autorelease pool (memory builds up)
void inefficientLoop(void) {
    for (NSInteger i = 0; i < 1000000; i++) {
        NSString *string = [NSString stringWithFormat:@"Number %ld", (long)i];
        // string not released until end of outer pool
    }
}

// With autorelease pool (memory released each iteration)
void efficientLoop(void) {
    for (NSInteger i = 0; i < 1000000; i++) {
        @autoreleasepool {
            NSString *string = [NSString stringWithFormat:@"Number %ld", (long)i];
            // string released at end of each iteration
        }
    }
}

// Nested autorelease pools
void nestedPools(void) {
    @autoreleasepool {
        NSString *outer = @"outer";

        @autoreleasepool {
            NSString *inner = [NSString stringWithFormat:@"%@ inner", outer];
            // inner released when inner pool drains
        }

        // outer released when outer pool drains
    }
}

// Background thread pools
void backgroundWork(void) {
    dispatch_async(dispatch_get_global_queue(
        DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        @autoreleasepool {
            // Background work
            NSString *result = [NSString stringWithFormat:@"Result"];
            NSLog(@"%@", result);
        }
    });
}

Use explicit autorelease pools in tight loops that create many temporary objects to prevent memory growth between autorelease pool drains.

Best Practices

1. Use weak for delegates and parent references to break retain cycles in common delegation and hierarchical patterns

2. Apply weak-strong dance in blocks when capturing self to prevent cycles while ensuring safe access during execution

3. Choose copy for mutable type properties like NSString and NSArray to prevent unexpected mutations by callers

4. Annotate nullability explicitly with nullable/nonnull to improve API clarity and Swift interoperability

5. Use autorelease pools in loops that create temporary objects to prevent memory buildup in long-running iterations

6. Bridge CF types explicitly with appropriate qualifiers to manage ownership transfer between ARC and manual reference counting

7. Avoid storing objects in C structs as ARC cannot manage them; use Objective-C classes or CF types instead

8. Check for nil after weak references as they can become nil at any time when the referenced object deallocates

9. Use NSPointerArray for weak collections when maintaining collections of observers or delegates to prevent cycles

10. Profile with Instruments to detect retain cycles, memory leaks, and excessive autoreleased object creation

Common Pitfalls

1. Creating retain cycles with strong delegates causes memory leaks; always use weak for delegate properties

2. Capturing self strongly in blocks without weak creates cycles when blocks are stored in properties

3. Forgetting strong reference in weak-strong dance allows self to deallocate during block execution

4. Using strong for parent pointers creates bidirectional strong references and prevents deallocation

5. Not using copy for NSString properties allows callers to pass mutable strings and modify them later

6. Bridging CF types incorrectly causes over-releases or leaks depending on ownership transfer direction

7. Storing ARC objects in C structures leads to premature deallocation or crashes as ARC cannot track them

8. Creating NSTimer without invalidation retains target strongly and prevents deallocation until invalidated

9. Missing autorelease pools in tight loops causes memory growth and potential crashes from memory pressure

10. Using unsafe_unretained instead of weak creates dangling pointers that crash when accessed after deallocation

When to Use This Skill

Use ARC patterns when writing Objective-C code for iOS, macOS, watchOS, or tvOS to ensure memory-safe applications without manual retain/release calls.

Apply weak references and the weak-strong dance when implementing delegates, observers, or callbacks that could create retain cycles.

Employ proper bridging when interfacing with Core Foundation, Core Graphics, or other C-based frameworks that use manual reference counting.

Leverage autorelease pools when processing large datasets, importing data, or performing other operations that create many temporary objects in loops.

Use appropriate ownership qualifiers when designing public APIs to clearly communicate memory management expectations to clients.

Resources

• Transitioning to ARC Release Notes
• Advanced Memory Management Programming Guide
• Working with Objective-C
• Instruments User Guide
• Core Foundation Design Concepts