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