Objective-C 与 C语言之间的转换
C语言的结构体(struct或union)成员中，如果存在Objective-C对象型变量，便会引起编译错误。
struct Data {
NSMutableArray *array;
}
error: ARC forbids Objective-C objs in structs or unions NSMutableArray *array;
虽然是LLVM编译器3.0，但不论怎样，C语言的规约上没有方法来管理结构体成员的生存周期。因为ARC把内存管理的工作分配给编译器，所以编译器必须能够知道并管理对象的生存周期。例如C语言的自动变量（局部变量）可使用该变量的作用域管理对象。但是对于C语的结构体成员来说，这在标准上就是不可实现的。
要把对象型变量加入到结构体成员中时，可强制转换为void *或是附加前面所述的__unsafe_unretained修饰符。
struct Data {
NSMutableArray __unsafe_unretained *array;
}
如前所述，附有_unsafe_unretained修饰符的变量不属于编译器的内存管理对象。如果管理时不注意赋值对象的所有者，便有可能遭遇内存泄漏或程序崩溃。这点在使用时应多加注意。
显式转换 id 和 void *
在MRC下，像以下代码这样将 id 变量强制转换成 void * 变量并不会出问题。
// MRC下
id obj = [[NSObject alloc] init];
void *p = obj;
更进一步，将改 void * 变量赋值给 id 变量中，调用其实例方法，运行时也不会有问题。
// MRC下
id 0 = p;
[o release];
但是以上代码在ARC下便会引起编译错误
error: implicit conversion of an objective-C pointer
to 'void*' is disallowed with ARC
void *p = obj;
^
error: implicit conversion of a non-Objective-C pointer
type 'void *' to 'id' is disallowed with ARC
id o = p;
id 型或对象型变量赋值给void * 或者逆向赋值时都需要进行特定的转换。如果只想单纯地赋值，则可以使用 "__bridge转换"。
OC指针与void *互相转换
使用 __bridge
#pragma mark - OC指针与void *互相转换，使用 __bridge
- (void)OCAndVoidUse__bridgeInARC {
id obj = [[NSObject alloc] init];
void *p = (__bridge void *)obj;
id o = (__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;
// p = (__bridge void *)obj; 报错，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;
}
在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对象之间的转化
除了Objective-C与C语言之间的转换之外，再介绍一下Objective-C对象与Core Foundation对象之间的转化。
以下函数可用于Objective-C对象与Core Foundation对象之间的相互转换，即Toll-Free Bridge(免费桥)转换。
// After using a CFBridgingRetain on an NSObject, the caller must take responsibility for calling CFRelease at an appropriate time.
NS_INLINE CF_RETURNS_RETAINED CFTypeRef _Nullable CFBridgingRetain(id _Nullable X) {
return (__bridge_retained CFTypeRef)X;
}
NS_INLINE id _Nullable CFBridgingRelease(CFTypeRef CF_CONSUMED _Nullable X) {
return (__bridge_transfer id)X;
}
将Core Foundation的对象转换为OC对象来处理
使用 __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 {
CFMutableArrayRef cfMutableArr = NULL;
{
// 变量obj持有对生成对象并持有对象的强引用
id obj = [[NSMutableArray alloc] init];
/**
*因为__bridge转换不改变对象的持有状况，
*所以只有通过变量obj的强引用，
*引用计数为“1”。
*/
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 ()手动释放。
总结
-
__bridge可以实现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，“被转换的变量”所持有的对象在变量赋值给“转换目标变量”后随之释放