C++长远解构iOS的block闭包完成原理

在iOS4出来后,苹果企业在OC中推出了block机制(也许更一度有了)。并且在此起彼伏的版本中多量的加大和应用了那项技能,比如对视图动画API的改版,比如GCD技术等等。block技术并不是何等新技巧,他的实质就是闭包成效在iOS上的兑现而已。而闭包成效在其余众多语言中都有落到实处,比如JAVA中接口的匿名已毕。用闭包可以解决那多少个进行逻辑和上下文环境解耦的情景,倘若从设计格局的角度来考虑的话闭包就是一种方针情势(Strategy)的实现。

本文并不追究怎么着利用block,而是研讨OC的block机制是什么样贯彻的。从代码的角度来说block的出现和大家日常依据函数和类措施的编程方式不太雷同,有时候依旧不佳去领会,因为她可以在大家的代码块中定义代码块,而且新定义的代码块又不会按函数内的命令顺序去执行。我们得以大胆的考虑,要是是要你去贯彻一套block机制,你会怎么去做?那也是本文要探索的事物,唯有你了然了OC达成block的底牌,你才可以更好的行使他。

写这篇文章来分析原理时自己隐去了有些细节,而且有些结构体的定义也和真实性的有差别,不过总体是不利的,目的是为着更好的摸底到精神的东西。大家先来看上边一段含有block的OC代码:

//文件test.m
#import <Foundation/Foundation.h>
void test()
{
    //下面分别定义各种类型的变量
     int a = 10;                       //普通变量
    __block int b = 20;                //带__block修饰符的block普通变量
    NSString *str = @"123"; 
    __block NSString *blockStr = str;  //带__block修饰符的block OC变量
    NSString *strongStr = @"456";      //默认是__strong修饰的OC变量
    __weak NSString *weakStr = @"789"; //带__weak修饰的OC变量

  //定义一个block块并带一个参数
    void (^testBlock)(int) = ^(int c){
         int  d = a + b + c;
         NSLog(@"d=%d, strongStr=%@, blockStr=%@, weakStr=%@", d, strongStr, blockStr, weakStr);
     };

    a = 20;  //修改值不会影响testBlock内的计算结果
    b = 40;  //修改值会影响testBlock内的计算结果。
    testBlock(30);  //执行block代码。
}

地点的代码片段中,大家独家定义了:

  • 不带修饰符的主导项目变量a
  • 带__block修饰符的block变量b和blockStr
  • 默认带__strong修饰符的变量strongStr
  • 带__weak修饰符的变量weakStr

那么些修饰符关键字的利用会对block块内的代码在运行时爆发分化的熏陶。就地点的代码片段而言当我们在编译时,编译器到底做了什么处理?要是能够明白到编译器的编译进度,那么对我们驾驭其促成机制就这个有帮扶。幸好大家可以依靠命令来见见那一个当中的长河,您能够打开终端控制台,并到test.m文件所在的门径下举行如下的指令:

   clang  -rewrite-objc  test.m

clang这几个命令会在同样目录下发生一个test.cpp的文本。那几个文件是OC代码的C++完成版本,因为大家知道C++是不帮助闭包技术的,因而你可以经过翻看test.cpp这些文件来询问到OC中的闭包技术到底是怎么着用函数和社团体来达成的。(注意下面的授命执行时会报错,提示不援救__weak类型的定义,我当下未曾找到解决方法,暂时是把
__weak修饰符去掉)
。大家可以先来看看test.cpp的一些完结:

struct __Block_byref_b_0 {
  void *__isa;
__Block_byref_b_0 *__forwarding;
 int __flags;
 int __size;
 int b;
};
struct __Block_byref_blockStr_1 {
  void *__isa;
__Block_byref_blockStr_1 *__forwarding;
 int __flags;
 int __size;
 void (*__Block_byref_id_object_copy)(void*, void*);
 void (*__Block_byref_id_object_dispose)(void*);
 NSString *blockStr;
};

struct __test_block_impl_0 {
  struct __block_impl impl;
  struct __test_block_desc_0* Desc;
  int a;
  NSString *strongStr;
  NSString *weakStr;
  __Block_byref_b_0 *b; // by ref
  __Block_byref_blockStr_1 *blockStr; // by ref
  __test_block_impl_0(void *fp, struct __test_block_desc_0 *desc, int _a, NSString *_strongStr, NSString *_weakStr, __Block_byref_b_0 *_b, __Block_byref_blockStr_1 *_blockStr, int flags=0) : a(_a), strongStr(_strongStr), weakStr(_weakStr), b(_b->__forwarding), blockStr(_blockStr->__forwarding) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
static void __test_block_func_0(struct __test_block_impl_0 *__cself, int c) {
  __Block_byref_b_0 *b = __cself->b; // bound by ref
  __Block_byref_blockStr_1 *blockStr = __cself->blockStr; // bound by ref
  int a = __cself->a; // bound by copy
  NSString *strongStr = __cself->strongStr; // bound by copy
  NSString *weakStr = __cself->weakStr; // bound by copy



        int d = a + (b->__forwarding->b) + c;

        NSLog((NSString *)&__NSConstantStringImpl__var_folders_d6_rtk49g5s52g_m2sgrvm0b5q00000gn_T_main_5b81f9_mi_3, d, strongStr, (blockStr->__forwarding->blockStr), weakStr);

    }
static void __test_block_copy_0(struct __test_block_impl_0*dst, struct __test_block_impl_0*src) {_Block_object_assign((void*)&dst->b, (void*)src->b, 8/*BLOCK_FIELD_IS_BYREF*/);_Block_object_assign((void*)&dst->strongStr, (void*)src->strongStr, 3/*BLOCK_FIELD_IS_OBJECT*/);_Block_object_assign((void*)&dst->blockStr, (void*)src->blockStr, 8/*BLOCK_FIELD_IS_BYREF*/);_Block_object_assign((void*)&dst->weakStr, (void*)src->weakStr, 3/*BLOCK_FIELD_IS_OBJECT*/);}

static void __test_block_dispose_0(struct __test_block_impl_0*src) {_Block_object_dispose((void*)src->b, 8/*BLOCK_FIELD_IS_BYREF*/);_Block_object_dispose((void*)src->strongStr, 3/*BLOCK_FIELD_IS_OBJECT*/);_Block_object_dispose((void*)src->blockStr, 8/*BLOCK_FIELD_IS_BYREF*/);_Block_object_dispose((void*)src->weakStr, 3/*BLOCK_FIELD_IS_OBJECT*/);}

static struct __test_block_desc_0 {
  size_t reserved;
  size_t Block_size;
  void (*copy)(struct __test_block_impl_0*, struct __test_block_impl_0*);
  void (*dispose)(struct __test_block_impl_0*);
} __test_block_desc_0_DATA = { 0, sizeof(struct __test_block_impl_0), __test_block_copy_0, __test_block_dispose_0};
void test()
{


    int a = 10;
    __attribute__((__blocks__(byref))) __Block_byref_b_0 b = {(void*)0,(__Block_byref_b_0 *)&b, 0, sizeof(__Block_byref_b_0), 20};
    NSString *str = (NSString *)&__NSConstantStringImpl__var_folders_d6_rtk49g5s52g_m2sgrvm0b5q00000gn_T_main_5b81f9_mi_0;
    __attribute__((__blocks__(byref))) __Block_byref_blockStr_1 blockStr = {(void*)0,(__Block_byref_blockStr_1 *)&blockStr, 33554432, sizeof(__Block_byref_blockStr_1), __Block_byref_id_object_copy_131, __Block_byref_id_object_dispose_131, str};
    NSString *strongStr = (NSString *)&__NSConstantStringImpl__var_folders_d6_rtk49g5s52g_m2sgrvm0b5q00000gn_T_main_5b81f9_mi_1;
     NSString *weakStr = (NSString *)&__NSConstantStringImpl__var_folders_d6_rtk49g5s52g_m2sgrvm0b5q00000gn_T_main_5b81f9_mi_2;

    void (*testBlock)(int) = ((void (*)(int))&__test_block_impl_0((void *)__test_block_func_0, &__test_block_desc_0_DATA, a, strongStr, weakStr, (__Block_byref_b_0 *)&b, (__Block_byref_blockStr_1 *)&blockStr, 570425344));

    a = 20;
    (b.__forwarding->b) = 40;
    ((void (*)(__block_impl *, int))((__block_impl *)testBlock)->FuncPtr)((__block_impl *)testBlock, 30);

}
static struct IMAGE_INFO { unsigned version; unsigned flag; } _OBJC_IMAGE_INFO = { 0, 2 };

地点的代码对于某些同学来说也许太过别扭了!然则尚未涉及,我把地点的代码举行简化和拍卖,并去掉了有些附带的东西,然后简化为如下的代码:

//  每个block变量都会生成一个和OC类内存结构兼容的结构体。下面是_block int b 的结构体定义:
struct Block_b {
    void *isa;    //固定为NULL
    Block_b *forwarding;  //指向真正的block对象变量。
    int flags;
    int size; //结构体的size
    int b;   //保存代码中定义的变量值。
};

//每个block变量都会生成一个和OC类内存结构兼容的结构体。下面是 __block NString *blockStr 的结构体定义:
struct Block_blockStr {
    void *isa;  //固定为NULL
    Block_blockStr *forwarding;  //指向真正的block对象变量
    int flags;
    int size;  //结构体的size
    NSString * blockStr;  //保存代码中定义的变量值。
};


//每个block块都会生成一个和OC类内存结构兼容的结构体和一个描述这个block块信息描述的结构体
struct Block_testBlock {
    //所有block块的固定部分,这也是一个OC类的内存结构。
    Class isa;  //block的OC类型
    int flags;
    int reserved;
    void *funcPtr;       //block块函数的地址。
    Block_testBlock_Desc* desc;   //block的描述信息。

    //所有在block代码块内引用的外部数据都会成为结构体内的数据成员。
    int a;
    NSString * strongStr;
    NSString * __weak weakStr;
    Block_b *b;
    Block_blockStr *blockStr;

    //结构体的构造函数。
    Block_testBlock(void *_funcPtr, Block_testBlock_Desc *_desc, int _a, NSString * _strongStr, NSString * _weakStr, struct Block_b *_b, Block_blockStr *_blockStr, int _flags)
    {
        isa = &_NSConcreteStackBlock;  //根据具体的block类型赋值。
        flags = _flags;
        reserved = 0;
        funcPtr = _funcPtr;
        desc = _desc;
        a = _a;
        strongStr = _strongStr;
        weakStr = _weakStr;
        b = _b->forwarding;  //b保存真实的block变量的地址。
        blockStr = _blockStr->forwarding;  //blockStr保存真实的block变量的地址。
    }
};

//block块信息描述的结构体定义,主要有block对象的尺寸,以及block中函数的参数信息,也就是参数的签名信息。并生成一个全局的常量对象_testBlock_desc_DATA
struct Block_testBlock_Desc {
    unsigned long reserved;
    unsigned long size; //块的尺寸
    void *rest[1];    //块的参数签名信息
}_testBlock_desc_DATA = {0, sizeof(Block_testBlock), "v12@?0i8"};


//这部分是block块函数体的定义部分,可以看出block的代码块都转化为了普通的函数,并且函数会默认增加一个隐藏的__cself参数,用来指向block对象本身。
static void testBlockfn(Block_testBlock *__cself, int c) {

    //还原函数体内引用外部的数据对象和变量。
    Block_b *b = __cself->b;
    Block_blockStr *blockStr = __cself->blockStr;
    int a = __cself->a;
    NSString *__strong strongStr = __cself->strongStr;
    NSString *__weak weakStr = __cself->weakStr;

    //int d = a + b + c;
    int d = a + b->forwarding->b + c;  //注意这里block变量使用方式。

    //NSLog(@"d=%d, strongStr=%@, blockStr=%@, weakStr=%@", d, strongStr, blockStr, weakStr);
    NSLog(@"d=%d, strongStr=%@, blockStr=%@, weakStr=%@", d, strongStr, blockStr->forwarding->blockStr, weakStr);

}

void test()
{
    int a = 10;

    //__block int b = 20;
    Block_b b = {nil, &b, 0, sizeof(struct Block_b), 20};

    // __block NSString *blockStr = @"123";
    Block_blockStr blockStr = {nil, &blockStr, 33554432, sizeof(Block_blockStr), @"123"};

    NSString *strongStr = @"456";

   __weak NSString *weakStr = @"789";

    //每个在代码中的block块都会生成对应的OC block对象,这里面用构造函数初始化这个block对象。
    Block_testBlock testBlock(&testBlockfn, &_testBlock_desc_DATA, a, strongStr, weakStr, &b, &blockStr, 570425344);

    a = 20;   //这个不会影响到block块内执行时a的值。
    // b = 40; 这个赋值会影响到block块内执行时b的值。
    b.forwarding->b = 40;  //注意__block类型变量的值的更新方式。

    //执行block块其实就是执行block对象里面的函数。
   //testBlock(30);
    testBlock.funcPtr(&testBlock, 30);
}

先看函数test内的兑现部分,我们发现装有带 __block修饰符的变量的概念由:

     __block int b = 20;
     __block NSString *blockStr = @"123"; 

变为了:

    Block_b b = {nil, &b, 0, sizeof(struct Block_b), 20};
    Block_blockStr blockStr = {nil, &blockStr, 33554432, sizeof(Block_blockStr), @"123"};

也就是说所有定义为__block类型的变量,在编译时都会化为一个个block对象变量。在编译时系统会为各样带__block修饰的变量生成一个和OC类内存结构极度的结构体:

//  每个block变量都会生成一个和OC类内存结构兼容的结构体。下面是_block int b 的结构体定义:
struct Block_b {
    void *isa;
    Block_b *forwarding;  //指向真正的block对象变量。
    int flags;
    int size;  //结构体的size。
    int b;   //保存代码中定义的变量。
};

//每个block变量都会生成一个和OC类内存结构兼容的结构体。下面是 __block NString *blockStr 的结构体定义:
struct Block_blockStr {
    void *isa;
    Block_blockStr *forwarding;  //指向真正的block对象变量。
    int flags;
    int size;
    NSString * blockStr;  //保存代码中定义的变量。
};

上边的多个结构体都有定点的格式,而且也和OC类的内存结构卓殊。也就是说当定义__block修饰的变量时,系统会把他转化为一个OC对象。
为什么要把__block定义的变量转变为OC对象呢?这一个是和__block这一个重中之重字所发挥的意思是相同的,也就是概念为__block类型的变量是不会在block代码块内发生副本的,而是保持唯一性。每个block对象变量的isa都固定设置为nil;
而forwarding则是指向真正操作的block对象变量,假诺某个block对象变量只是在一个栈block对象里面被运用则那时候forwarding是指向block对象变量自己,而只要这一个block对象变量在一个堆block对象里面被应用则那时候forwarding则是指向一个堆block对象变量的地点。

再来看test函数中的block块的定义部分。从代码中得以窥见原本在代码中定义的block块,被拆分为了block对象和全局函数两局部来落到实处。由此得以见见在iOS内享有定义的block代码块系统在编译时都会转接为个OC对象(NSBlock类是用来讲述block代码块的OC类,系统累计协理栈block:NSStackBlock,堆block:NSMallocBlock,全局block:NSGlobalBlock二种档次的block。具体的细节和出入不在本文展开,请大家自行检索有关的素材。)。由此在编译时大家会为种种block代码块都生成一个和OC类包容的结构体,在大家的例证里面的社团体定义如下:

//每个block块都会生成一个和OC类兼容的结构体。
struct Block_testBlock {
    //前面5个数据成员在所有block定义中都相同,并且和OC兼容。
    Class isa;
    int flags;
    int reserved;
    void *funcPtr;   //block块的全局函数的地址。
    Block_testBlock_Desc* desc;   //block的描述。

    //所有在block代码块引用的外部数据都会成为结构体的同名数据成员。
    int a;
    NSString * strongStr;
    NSString * __weak weakStr;
    Block_b *b;
    Block_blockStr *blockStr;

    //结构体的构造函数。
    Block_testBlock(void *_funcPtr, Block_testBlock_Desc *_desc, int _a, NSString * _strongStr, NSString * _weakStr, struct Block_b *_b, Block_blockStr *_blockStr, int _flags)
    {
        isa = &_NSConcreteStackBlock;  //根据具体的block类型赋值。
        flags = _flags;
        reserved = 0;
        funcPtr = _funcPtr;
        desc = _desc;
        a = _a;
        strongStr = _strongStr;
        weakStr = _weakStr;
        b = _b->forwarding;  //其实就是指向自己
        blockStr = _blockStr->forwarding;
    }
};

//每个block块的描述信息结构体,主要是保存block的尺寸,以及block中函数的参数信息。
struct Block_testBlock_Desc {
    unsigned long reserved;
    unsigned long size; //块的尺寸
    void *rest[1];    //块的参数签名信息
}_testBlock_desc_DATA = {0, sizeof(Block_testBlock), "v12@?0i8"};

可以看到我们定义的block代码块都会扭转2个结构体:

  • Block_testBlock用来保存block的新闻以及block内部要用到的享有数据。所有block对象结构体的前5个数据成员都是同等的,也就是和OC类的内存结构是合作的。其中的isa用来保存block的类音信,那其间的类新闻会基于block所处的地点的不比而各异。而背后的5个数据成员即便在block代码块内选择外部对象的副本。正是因为各类block对象在编译时保留了代码块内尔y用代码块外的目的的副本,所以大家才能在继续代码执行时可以访问到那个音信。

  • Block_testBlock_Desc用来叙述这几个block的size以及block方法的参数的署名新闻。

下边就是Block_testBlock 实例的构造方法:

  //每个在代码中的block块都会生成对应的OC  block对象,这里面构造函数初始化这个block对象。
    Block_testBlock testBlock(&testBlockfn, &_testBlock_desc_DATA, a, strongStr, weakStr, &b, &blockStr, 570425344);

上面可以看看,一旦在代码中冒出了block代码块,编译时就会建立一个block对象,然后将block对象关系的函数代码地址、以及利用的外侧的数码作为block对象的构造函数的参数来创立那一个block对象。

末段我们再来考察block代码的全局函数的落到实处:

//这部分是block代码函数体的定义部分,可以看见函数默认增加一个隐藏的__cself参数。
static void testBlockfn(Block_testBlock *__cself, int c) {

    //还原函数体内引用外面的变量。
    Block_b *b = __cself->b;
    Block_blockStr *blockStr = __cself->blockStr;
    int a = __cself->a;
    NSString *__strong strongStr = __cself->strongStr;
    NSString *__weak weakStr = __cself->weakStr;


    //int d = a + b + c;
    int d = a + (b->forwarding->b) + c;

    //NSLog(@"d=%d, strongStr=%@, blockStr=%@, weakStr=%@", d, strongStr, blockStr, weakStr);
    NSLog(@"d=%d, strongStr=%@, blockStr=%@, weakStr=%@", d, strongStr, blockStr->forwarding->blockStr, weakStr);

}

地方的代码片段中,可以看到block块全局函数除了定义的int类型参数外,还扩大了一个藏匿的参数__cself用来指向block对象。然后在函数体的发端地点把施用的表面数据的副本还原到函数的栈内。那也是怎么大家能在block代码块内用到外围的多寡的原故了。那里我们要求越来越寓目那多少个副本的意思:

  • 对此着力类型a的副本来说就是截然的内存拷贝,由此在block代码块内更新那一个多少是不会潜移默化到外围,同时外面的更新也不会影响到里面了。

  • 对此目的类型的strongStr和weakStr而言那个副本只是指针的正片而不是所指对象的正片,由此在block代码块内可以读取最新的特性和装置新的属性值。

  • 对于__block类型的对象的话,你会发现她也是指针的正片,所以也不会时有发生多份内存副本,同时可以看出对__block类型数据的读取和安装我们都是直接来成功的,由此那里代码块内更新数据能影响外面,同时外面的创新也能影响内部。

好了,所有我要介绍的始末就到此处了,上面就是iOS的block的其中贯彻机制。我相信经过自身上边的牵线可以让你精晓到了block在编译时所做的事务,以及可以通晓到__block,
__weak, __strong种种修饰符的意思和差别。


最后欢迎大家访问我的github站点,关注欧阳二弟2013