iOS桥接__bridge，__bridge_transfer，__bridge_retained了解一下

有时候你可能需要用到一些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，“被转换的变量”所持有的对象在变量赋值给“转换目标变量”后随之释放