本文是对《Objective-C高级编程》中__bridge部分的整理，加上一部分自己的体会。

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，“被转换的变量”所持有的对象在变量赋值给“转换目标变量”后随之释放