Understanding bridged casts
With ARC, Objective-C introduced bridged casts, which are C-style casts between toll-free bridged types annotated with either __bridge, __bridge_transfer or __bridge_retained. Using them appropriately is important to avoid memory leaks and crashes, but it can be confusing to know which one to choose.
Though clear, the Apple documentation is abstract:
The compiler does not automatically manage the lifetimes of Core Foundation objects. You tell the compiler about the ownership semantics of objects using either a cast (defined in objc/runtime.h) or a Core Foundation-style macro (defined in NSObject.h):
__bridge transfers a pointer between Objective-C and Core Foundation with no transfer of ownership.
__bridge_transfer or CFBridgingRelease moves a non-Objective-C pointer to Objective-C and also transfers ownership to ARC. ARC is responsible for relinquishing ownership of the object.
__bridge_retained or CFBridgingRetain casts an Objective-C pointer to a Core Foundation pointer and also transfers ownership to you. You are responsible for calling CFRelease or a related function to relinquish ownership of the object.
Let’s take a more concrete perspective on this.
According to the Apple documentation, there is no transfer of ownership with __bridge. What does this mean?
In the following example, we create an object in the Core Foundation world and access it as a NSString in the NSObject world:
CFStringRef stringRef = CGPDFStringCopyTextString(...); NSString *text = (__bridge NSString *)stringRef; // ... CFRelease(stringRef);
When we instantiate an object with CGPDFStringCopyTextString, its reference count is 1. With __bridge, ARC doesn’t act. Only by making text point to the object, we create a strong reference to this object, increasing its reference count by 1. ARC takes care of decreasing the reference count by 1 when this strong reference isn’t used anymore. There is still the initial reference count from the object’s creation — we need to manually release the object with CFRelease.
Our example, again, with the reference count of our object in the comments:
CFStringRef stringRef = CGPDFStringCopyTextString(...); // 1 (creation) NSString *text = (__bridge NSString *)stringRef; // 2 (text adds a strong reference) // ... NSLog(@"text = %@", text); // 1 (last use of text, ARC release) CFRelease(stringRef); // 0
The more elegant solution here is to use __bridge_transfer.
__bridge_transfer will transfer the ownership of the object to ARC. The compiler takes over the responsibility for releasing the object.
This enables us to rewrite our code:
CFStringRef stringRef = CGPDFStringCopyTextString(...); // 1 (creation) NSString *text = (__bridge_transfer NSString *)stringRef; // 1 (compiler transfers ownership to ARC) // ... NSLog(@"text = %@", text); // 0 (last use of text, ARC release)
It behaves as if we were creating a strong ARC-managed reference to our object while decreasing its reference count with CFRelease:
CFStringRef stringRef = CGPDFStringCopyTextString(...); // 1 (creation) NSString *text = (__bridge NSString *)stringRef; // 2 (text adds a strong reference) CFRelease(stringRef); // 1 // ... NSLog(@"text = %@", text); // 0 (last use of text, ARC release)
What happens when we cast a NSObject into a C object?
If we just use a __bridge cast, the compiler doesn’t do anything. ARC releases our object when no more strong references are present:
NSString *text = [[NSString alloc] init]; // 1 CFStringRef stringRef = (__bridge CFStringRef)text; // 1 // ... do something with stringRef NSLog(@"text = %@", text); // 0 (last use of text, ARC release)
The problem is that we don’t control the lifetime of our object. ARC will release it as soon as it sees no more strong references to it. The following code will crash [1]:
NSString *text = [[NSString alloc] init]; // 1 CFStringRef stringRef = (__bridge CFStringRef)text; // 1 // ... NSLog(@"text = %@", text); // 0 (last use of text, ARC release) // do something with stringRef // ** CRASH **
__bridge_retained comes in handy to take ownership of an object during a cast: the reference count of our object is increased. When ARC decreases the reference count because it doesn’t see any later reference, our object stays alive. You now own this object, though; don’t forget to release it:
NSString *text = [[NSString alloc] init]; // 1 CFStringRef stringRef = (__bridge_retained CFStringRef)text; // 2 NSLog(@"text = %@", text); // 1 (last use of text, ARC decrease refs) // We can safely keep using myStringRef. // ... CFRelease(myStringRef); // 0
When using bridged casts, keep in mind who created the object (the initial owner) and who is responsible for releasing it (the current owner, it might not be the initial one if the ownership was already transferred).
If you own a Core Foundation object, use __bridge_transfer to cast it to the NSObject world: ARC is now the owner and you don’t have to deal with releasing it. If you don’t own it, use __bridge — the owner is responsible for releasing it.
If you are bridging in the other direction, ARC generally owns the object. Use __bridge if you know that ARC won’t release the object before you need it. Otherwise, choose __bridge_retained to ensure your object survives even if ARC doesn’t have any strong reference left pointing to it.
Thanks Patrick for reading drafts of this post.
[1] It might not always crash depending on how aggressively the compiler optimizes local variables. In debug mode, for instance, ARC releases objects at the end of the scope and not right after their last use.
germansingergirl
snowghoul
vaporwave
ellievsbear
pixelskylines
jbbartram-illu
dailybridgerton
gummygunk