Skill v1.0.1

currentAutomated scan100/100

thebushidocollective/han/objc-arc-patterns

4 files

──Details

PublishedSeptember 28, 2026 at 08:55 PM

Content Hashsha256:14d40716e2d56f0c...

Git SHA19caa51d5fd1

Bump Typepatch

Compare with v1.0.0

──Files

Files (1 file, 20.1 KB)

SKILL.md20.1 KBactive

SKILL.md · 713 lines · 20.1 KB

version: "1.0.1" name: Objective-C ARC Patterns user-invocable: false description: Use when automatic Reference Counting in Objective-C including strong/weak references, retain cycles, ownership qualifiers, bridging with Core Foundation, and patterns for memory-safe code without manual retain/release. allowed-tools: []

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.

objectivec

// 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.

objectivec

// 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.

objectivec

// 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.

objectivec

// 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.

objectivec

// 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.

objectivec

// 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

Use weak for delegates and parent references to break retain cycles in

common delegation and hierarchical patterns

Apply weak-strong dance in blocks when capturing self to prevent cycles

while ensuring safe access during execution

Choose copy for mutable type properties like NSString and NSArray to

prevent unexpected mutations by callers

Annotate nullability explicitly with nullable/nonnull to improve API

clarity and Swift interoperability

Use autorelease pools in loops that create temporary objects to prevent

memory buildup in long-running iterations

Bridge CF types explicitly with appropriate qualifiers to manage

ownership transfer between ARC and manual reference counting

Avoid storing objects in C structs as ARC cannot manage them; use

Objective-C classes or CF types instead

Check for nil after weak references as they can become nil at any time

when the referenced object deallocates

Use NSPointerArray for weak collections when maintaining collections of

observers or delegates to prevent cycles

Profile with Instruments to detect retain cycles, memory leaks, and

excessive autoreleased object creation

Common Pitfalls

Creating retain cycles with strong delegates causes memory leaks; always

use weak for delegate properties

Capturing self strongly in blocks without weak creates cycles when blocks

are stored in properties

Forgetting strong reference in weak-strong dance allows self to

deallocate during block execution

Using strong for parent pointers creates bidirectional strong references

and prevents deallocation

Not using copy for NSString properties allows callers to pass mutable

strings and modify them later

Bridging CF types incorrectly causes over-releases or leaks depending on

ownership transfer direction

Storing ARC objects in C structures leads to premature deallocation or

crashes as ARC cannot track them

Creating NSTimer without invalidation retains target strongly and

prevents deallocation until invalidated

Missing autorelease pools in tight loops causes memory growth and

potential crashes from memory pressure

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

← v1.0.0 All versions