有时候你可能需要用到一些Core Foundation对象（比如CFArrayRef或者CFMutableDictionaryRef），对于这些对象，编译器是不会自动管理它们的生命周期的，你需要使用CFRetain或CFRelease之类的方法来管理它们的持有情况（ownership）。
如果要进行Core Foundation对象和Objective-C对象的相互转换，就可以使用Toll-Free Bridging。
而由于ARC已不能直接使用retain、release等方法，那么在转换的时候就需要将CF指针的持有情况告知OC指针，同理OC指针在转换成CF指针时也要告知其持有情况。
OC指针与C互相转换
使用 __bridge
#pragma mark - OC指针与C互相转换，使用 __bridge
- (void)OCAndC__bridgeInARC {
id obj = [[NSObject alloc] init];
void *p = (__bridge void *)obj;
obj = (__bridge id)(p);
}
像这样，通过__bridge转换，id和 void * 就能够相互转换。但是转换为 void * 的 __bridge转换，其安全性与赋值给 __unsafe_unretained 修饰符相近，甚至会更低。如果管理时不注意赋值对象的所有者，就会因悬垂指针而导致程序崩溃。
注意：此时指针变量 p并没有持有对象，因为__bridge并不会改变持有情况。
OC指针转换为void *指针
ARC下使用 __bridge_retained
#pragma mark - OC指针转换为void *指针，ARC下使用 __bridge_retained
- (void)OCToVoid__bridge_retainedInARC {
void *p = 0;
{
id obj = [[NSObject alloc] init];
p = (__bridge_retained void *)obj; //1
// p = (__bridge void *)obj; //2 报错，obj出了作用域就会销毁，__bridge不改变持有情况，所以p成为悬垂指针
}
NSLog(@"class===%@",[(__bridge id)p class]);
}
下面我们看看在MRC下源代码是如何编写的。
#pragma mark - OC指针转换为void *指针，MRC下
- (void)OCToVoid__bridge_retainedInMRC {
/* MRC下 */
void *p = 0;
{
id obj = [[NSObject alloc] init];
NSLog(@"obj retainCount===%lu",[obj retainCount]);
/* [obj retainCount] -> 1 */
p = [obj retain];
NSLog(@"obj retainCount===%lu",[obj retainCount]);
/* [obj retainCount] -> 2 */
[obj release];
NSLog(@"obj retainCount===%lu",[obj retainCount]);
/* [obj retainCount] -> 1 */
}
NSLog(@"(id)p retainCount===%lu",[(id)p retainCount]);
/**
* [(id)p retainCount] -> 1
* 即
* [obj retainCount] -> 1
* 对象仍然存在
*/
NSLog(@"class===%@",[(__bridge id)p class]);
}
__bridge_retained 转换可使要转换赋值的变量也持有该对象。
__bridge_retained 转换变为了 retain。
变量obj和变量p同时持有对象。
变量作用域结束时，虽然随着持有强引用的变量obj失效，对象随之释放，但由于 __bridge_retained 转换使变量p看上去处于持有该对象的状态，因此该对象不会被废弃。
void *指针转换为OC指针
ARC下使用 __bridge_transfer
#pragma mark - void *指针转换为OC指针，ARC下使用 __bridge_transfer
- (void)VoidToOC__bridge_transferInARC {
void *p = 0;
{
id tempObj = [[NSObject alloc] init];
p = (__bridge_retained void *)tempObj;
}
id obj = (__bridge_transfer id)p;
NSLog(@"class===%@",[obj class]);
}
在MRC下源代码。
#pragma mark - void *指针转换为OC指针，MRC下
- (void)VoidToOC__bridge_transferInMRC {
void *p = 0;
{
id tempObj = [[NSObject alloc] init];
p = [tempObj retain];
[tempObj release];
}
id obj = (id)p;
/**
* 同__bridge_retained转换与retain类似，__bridge_transfer转换与release相似。
* 在给id obj 赋值时retain即相当于__strong修饰符的变量。
*/
[obj retain];
[(id)p release];
}
__bridge_transfer 转换与 __bridge_retained 相反，“被转换的变量”所持有的对象在变量赋值给“转换目标变量”后随之释放
同__bridge_retained 转换与retain类似，__bridge_transfer转换与release相似。在给 id obj 赋值时 retain 即相当于 __strong 修饰符的变量。
Objective-C对象与Core Foundation对象之间的转化
使用__bridge
#pragma mark - 将Core Foundation的对象转换为OC对象来处理，使用 __bridge
static __weak id testPointer = nil;
- (void)CoreFoundationToOC__bridge {
// 创建一个作用域，目的是测试Core Foundation框架的对象会不会在作用结束后自动回收
{
/**
CFMutableArrayRef是CF框架下的类型，编译器无法自动管理内存，也就是说系统不会主动释放CFMutableArrayRef的变量，不手动释放就会内存泄露
Core Foundation框架生成并持有对象，之后的对象引用计数为“1”。
*/
CFMutableArrayRef cfMutableArr = CFArrayCreateMutable(kCFAllocatorDefault, 0, NULL);
// __bridge转换不改变对象的持有情况
testPointer = (__bridge id)cfMutableArr;
// testPointer = CFBridgingRelease(cfMutableArr); 报错,因为CFBridgingRelease()会立即释放cfMutableArr，弱指针立即置为nil
// 作用域内打印引用计数
CFIndex count = CFGetRetainCount(cfMutableArr);
NSLog(@"count===%ld",count);// count===1
}
/**
作用域外打印仍然是1，可见作用域结束后并不能销毁Core Foundation框架的对象，发生内存泄漏
*/
CFMutableArrayRef cfTemp = (__bridge CFMutableArrayRef)testPointer;
CFIndex count2 = CFGetRetainCount(cfTemp);
NSLog(@"count2===%ld",count2);// count2===1
/**
方法作用域外打印引用计数
*/
[self printOutOfMethodScope];
}
// MARK:方法作用域外打印引用计数
- (void)printOutOfMethodScope {
/**
虽然count3显示是2，但是只要调用CFRelease释放一次，CFGetRetainCount()就会崩溃，因为实际上RetainCount是1，所以这应该是个系统bug😊
CFIndex count3 = CFGetRetainCount((__bridge CFMutableArrayRef)(testPointer));
CFRelease((__bridge CFMutableArrayRef)testPointer);
NSLog(@"count3===%ld",count3);// count3===2
NSLog(@"count4===%ld",CFGetRetainCount((__bridge CFMutableArrayRef)(testPointer)));// 崩溃
*/
// 在方法作用域外打印引用计数仍然是“1”，可见cfMutableArr如不妥善管理，极易造成内存泄露
CFMutableArrayRef cfTemp = (__bridge CFMutableArrayRef)testPointer;
CFIndex count3 = CFGetRetainCount(cfTemp);
NSLog(@"count3===%ld",count3);// count3===1
}
同OC与 void *之间一样，__bridge可以实现Core Foundation对象与OC对象相互转换，但是__bridge仍然不改变持有情况。
将Core Foundation的对象转换为OC对象来处理
使用CFBridgingRelease()或__bridge_transfer
#pragma mark - 将Core Foundation的对象转换为OC对象来处理，使用CFBridgingRelease或__bridge_transfer
static __weak id testPointer2 = nil;
- (void)CoreFoundationToOC__bridge_transferAndCFBridgingRelease {
{
CFMutableArrayRef cfMutableArray = CFArrayCreateMutable(kCFAllocatorDefault, 0, NULL);
/**
*Core Foundation框架的API生成并持有对象，之后的对象引用计数为“1”。
*/
NSLog(@"RetainCount===%ld",CFGetRetainCount(cfMutableArray));// RetainCount===1
/**
*通过CFBridgingRelease赋值，变量obj持有对象强引用的同时，cfMutableArray指针对于对象的强引用通过CFBridgingRelease释放。
*/
id obj = CFBridgingRelease(cfMutableArray); // 或者id obj = (__bridge_transfer id)cfMutableArray;
// 用testPointer2这个弱指针来跟踪obj，在出了作用域后最终是否被释放
testPointer2 = obj;
NSLog(@"weak===%@",testPointer2); // weak===( )
// 因为只有obj持有对象的强引用，故引用计数为“1”。
NSLog(@"RetainCount after the cast===%ld",CFGetRetainCount(cfMutableArray));// RetainCount after the cast===1
// 另外，因为经由CFBridgingRelease转换后，赋值给cfMutableArray中的指针也指向仍然存在的对象，所以可以正常使用。
NSLog(@"class===%@",[obj class]);// class===__NSCFArray
}
// 出了作用域后obj就立即被释放了，所以弱指针testPointer2才会为nil
NSLog(@"weak after the cast===%@",testPointer2);// weak after the cast===(null)
}
CFBridgingRelease()内部实现就是__bridge_transfer，类似release，原Core Foundation对象会被立即释放。赋值给OC对象后，编译器会自动管理内存。
将OC对象转换为Core Foundation的对象来处理
使用 __bridge
#pragma mark - 将OC对象转换为Core Foundation的对象来处理，使用 __bridge
- (void)OCToCoreFoundation__bridge {
// 变量obj持有对生成对象并持有对象的强引用
id obj = [[NSMutableArray alloc] init];
/**
*因为__bridge转换不改变对象的持有状况，
*所以只有通过变量obj的强引用，
*引用计数为“1”。
*/
CFMutableArrayRef cfMutableArr = (__bridge CFMutableArrayRef)obj;
CFShow(cfMutableArr);
NSLog(@"RetainCount===%ld",CFGetRetainCount(cfMutableArr));
/**
* 因为变量obj超出其作用域，
* 所以其强引用失效，对象得到释放，
* 无持有者的对象被废弃。
*/
/**
* 此后对对象的访问出错！（悬垂指针）
*/
NSLog(@"RetainCount after the scope===%ld",CFGetRetainCount(cfMutableArr));
CFRelease(cfMutableArr);
}
__bridge不改变对象的持有状况，所以OC对象obj在出了作用域会被系统自动释放，不可在对cfMutableArr做释放操作。
将OC对象转换为Core Foundation的对象来处理
使用 CFBridgingRetain() 或 __bridge_retained
#pragma mark - 将OC对象转换为Core Foundation的对象来处理，使用CFBridgingRetain或__bridge_retained
- (void)OCToCoreFoundation__bridge_retainedAndCFBridgingRetain {
CFMutableArrayRef cfMutableArr = NULL;
{
// 变量obj持有对生成对象并持有对象的强引用
id obj = [[NSMutableArray alloc] init];
/**
*通过CFBridgingRetain或者__bridge_retained，
*将对象CFRetain，
*赋值给变量cfMutableArr
*/
cfMutableArr = (__bridge_retained CFMutableArrayRef)obj;// 或者CFBridgingRetain(obj)
/**
* 通过obj的强引用和
* 通过__bridge_retained，
* 引用计数为“2”
*/
CFShow(cfMutableArr);
NSLog(@"RetainCount===%ld",CFGetRetainCount(cfMutableArr)); // RetainCount===2
}
/**
* 因为变量obj超出其作用域，所以其强引用失效，
* 引用计数为“1”
*/
NSLog(@"RetainCount after the scope===%ld",CFGetRetainCount(cfMutableArr));
CFRelease(cfMutableArr);
/**
* 因为将对象CFRelease，所以其引用计数为“0”
* 故该对象被废弃。
*/
}
CFBridgingRetain() 内部实现就是 __bridge_retained ，类似retain，Core Foundation对象cfMutableArr会持有OC对象。编译器不会自动管理Core Foundation对象的内存，需要调用CFRelease ()手动释放。
总结
__bridg可以实现Objective-C与C语言变量 和 Objective-C与Core Foundation对象之间的互相转换
__bridge不会改变对象的持有状况，既不会retain，也不会release
__bridge转换需要慎重分析对象的持有情况，稍不注意就会内存泄漏
__bridge_retained用于将OC变量转换为C语言变量 或 将OC对象转换为Core Foundation对象
__bridge_retained类似于retain，“被转换的变量”所持有的对象在变量赋值给“转换目标变量”后持有该对象
__bridge_transfer用于将C语言变量转换为OC变量 或 将Core Foundation对象转换为OC对象
__bridge_transfer类似于release，“被转换的变量”所持有的对象在变量赋值给“转换目标变量”后随之释放
