1 基本说明
Block一直是OC的一个重点、难点、黑科技。Block在日常项目中经常使用，他的实现方式和一般的oc代码不一样。同时也很容易出现使用不慎的情况。我们知道OC的本质是C语言+runtime。runtime中的具体实现完全就是汇编加上C语言。而且我们发现大部分都是通过结构体实现的。我们可以通过clang -rewrite-objc main.m 这种命令把包含Block的main.m函数反编译(注意：这里所说的反编译并不是真正的反编译，只是把OC源码转换为对等的C++源码)为为C++的具体实现。下面我就会通过这个命令来分析一下Block转换以后的源码。下面所有列子中转换前的代码都在main.m中，替换后的代码都在mainX.cpp中.
2 void (*block)(void)类型解析
我们先看一下转换以前的代码。顶一个一个block。只定义一个变量i并且赋值为1。对应的文件为mainX.cpp。
int main() {
void (^blk)(void) = ^(){
int i = 1;
};
blk();
return 0;
}下面是转换以后的代码。
struct __block_impl {
void *isa;
int Flags;
int Reserved;
void *FuncPtr;
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
int i = 1;
}
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int flags=0) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
static struct __main_block_desc_0 {
size_t reserved;
size_t Block_size;
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0)};
int main() {
void (*blk)(void) = ( (void (*)()) & __main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA) );
((void (*)(__block_impl *))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk);
return 0;
}上面是我截取的关键部分源码，其他还有很多辅助性的代码，这里我们就不用管了。看这段代码我们发现一个简单的block的转换成C++以后增加了很多代码：
main函数入口，我们可以发现这个函数里面主要初始化了一个
__main_block_impl_0的结构体。并且调用结构体的FuncPtr方法。__main_block_impl_0结构体。这个结构体有一个__block_impl和__main_block_desc_0结构体。以及一个初始化函数。__block_impl结构体。这个结构体有四个变量。其中我们可以发现有两个很关键的isa和FuncPtr。__main_block_desc_0结构体。这个结构体包含了两个size_t类型的属性，主要用于记录Block的内存大小。__main_block_func_0静态方法，我们发现这个方法就是BLock的具体实现。
2.1具体流程分析
首先main函数代码。
int main() {
void (*blk)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA));
((void (*)(__block_impl *))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk);
return 0;
}我们把它具体简化以后如下：
struct __main_block_impl_0 tmp = __main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA);
struct __main_block_impl_0 *blk = &tmp;
(*blk->impl.FuncPtr)(blk);
1首先初始化一个
__main_block_impl_0结构体变量。并且传入的参数是__main_block_func_0指向结构体的具体实现。__main_block_desc_0_DATA是__main_block_desc_0结构体的一个变量，主要目的是指定结构体的大小。2 把
tmp的地址赋值给blk指针。3 通过
blk找到他的impl属性，然后再通过impl这个__block_impl变量获取FuncPtr函数的地址。然后传入blk的指针作为参数。从而实现OC中的blk();这句话。
接下来我们看一下__main_block_impl_0这个结构体。
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int flags=0) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};这个结构体主要有一个初始化函数，通过传入结构体具体实现的函数指针fp，记录大小描述信息的参数desc，已经一个标记为flags。通过他来初始化__block_impl和__main_block_desc_0。
__block_impl这个结构体我们从他的结构发现和OC的类结构体有点像。他的isa属性其实就是OC的isa属性有异曲同工的作用，用于指向结构体的具体类型。FuncPtr函数指针就是指向Block具体实现的函数。
3 int (*block)(int)类型解析
废话少说，上代码。通过代码我们发现和上面那种没有什么区别。主要是__main_block_func_0函数的实现多了返回值和多了一个参数。具体看代码注释。
int main() {
int (^blk)(int i) = ^(int i){
int result = i + 1;
return result;
};
blk(3);
return 0;
}
//==============上面是反编译以前的代码==================
struct __block_impl {
void *isa;//isa表明结构体类型。
int Flags;
int Reserved;
void *FuncPtr;//指向函数指针
};
//这个结构体及时Block反编译以后生成的主要结构。
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
//初始化函数
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int flags=0) {
impl.isa = &_NSConcreteStackBlock;//表示这个Block是存储于栈上。
impl.Flags = flags;
impl.FuncPtr = fp;//函数指针赋值
Desc = desc;
}
};
//这个函数就是Block的具体实现，并且添加了一个默认实现。
static int __main_block_func_0(struct __main_block_impl_0 *__cself, int i) {
int result = i + 1;
return result;
}
//Block的描述信息
static struct __main_block_desc_0 {
size_t reserved;
size_t Block_size;
};
//__main_block_desc_0的一个实例，其中Block_size初始化为__main_block_impl_0结构体的大小。
struct __main_block_desc_0 __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0)};
int main() {
//int (*blk)(int i) = ((int (*)(int))&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA));
//上面一行转换为下面两行等价
struct __main_block_impl_0 tmp = __main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA);
struct __main_block_impl_0 *blk = &tmp;
//int blkRerurn = ((int (*)(__block_impl *, int))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk, 3);
//下面一行是上面一行的简化版
(*blk->impl.FuncPtr)(blk,3);
return 0;
}4 带__block变量的void (*block)(void)类型解析
我们发现加入一个带__block标志位的变量以后，代码复杂了很多。具体如下：
多了
__Block_byref_i_0结构体。这个结构体就是__block变量i直接生成的。多了两个函数
__main_block_copy_0和__main_block_dispose_0。这两个函数主要用于处理block复制的时候，对应的__block变量i的处理。__main_block_impl_0结构体多了一个__Block_byref_i_0类型的属性i。这个i就是对应于block里面的变量。__main_block_desc_0结构体多了两个函数。copy和dispose。在初始化结构体的时候，传入上面新增的两个函数作为参数。每个__block变量都回生成一个对应的结构体，并且作为
__main_block_impl_0结构体的属性。
通过对结构体__main_block_impl_0的初始化函数和__main_block_func_0方法的分析。我们可以得到如下结论：
__block变量i在转换为c语言后直接转换为一个
__Block_byref_i_0类型的结构体。__main_block_impl_0结构体中的i指针用于存储__block结构体变量，也就是block里面的那个i对象。block外面的那个i其实是block里面的i变量通过
i->__forwarding->i来获取的。当我们在block里面改变i的值的时候，其实是间接的通过i->__forwarding->i来改变。其中第一个i是block里面的变量。第二个i是block外边的变量。这样就解释了为什么block里面改变i的值block外面的i改变的原因。非block类型的变量在block里面是直接引用，不会生成专门的结构体。
同时我们也注意到__main_block_copy_0和__main_block_dispose_0这两个函数，我们虽然不能找到他的具体实现，不过可以根据上下文做一下具体的猜测：
//当我们复制block的时候。分别传入两个block的block变量的指针，然后做处理。
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {
_Block_object_assign((void*)&dst->one, (void*)src->one, 8);
}
//当我们销毁一个block后，估计会调用这个函数的block变量的指针，做销毁操作
static void __main_block_dispose_0(struct __main_block_impl_0*src) {
_Block_object_dispose((void*)src->one, 8);
}完整代码如下：
#include "stdio.h"
#define NORMAL
typedef void (^Block)();
int main() {
@autoreleasepool {
__block int i = 1;
Block block1 = ^(){
i = 2;
printf("%d",i);
};
block1();
}
return 0;
}
//==============上面是反编译以前的代码==================
typedef void (*Block)();
struct __block_impl {
void *isa;
int Flags;
int Reserved;
void *FuncPtr;
};
//这个结构体是专门为了__block变量i生成的。
struct __Block_byref_i_0 {
void *__isa;
__Block_byref_i_0 *__forwarding;
int __flags;
int __size;
int i;
};
//多了一个__Block_byref_i_0变量
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
__Block_byref_i_0 *i; // 多了一个i属性。block变量
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_i_0 *_i, int flags=0) : i(_i->__forwarding) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
//Block的具体实现。从这里我们发现为啥改变i的值的猫腻。
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
__Block_byref_i_0 *i = __cself->i; // bound by ref
(i->__forwarding->i) = 2;
printf("%d",(i->__forwarding->i));
}
//用于管理i变量的声明周期。复制一个block的时候，复制他对应的i变量。
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {
_Block_object_assign((void*)&dst->i, (void*)src->i, 8/*BLOCK_FIELD_IS_BYREF*/);
}
//用于管理i变量的声明周期
static void __main_block_dispose_0(struct __main_block_impl_0*src) {
_Block_object_dispose((void*)src->i, 8/*BLOCK_FIELD_IS_BYREF*/);
}
//多了两个指针函数、
static struct __main_block_desc_0 {
size_t reserved;
size_t Block_size;
void (*copy)(struct __main_block_impl_0*, struct __main_block_impl_0*);
void (*dispose)(struct __main_block_impl_0*);
};
//实例变量
struct __main_block_desc_0 __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0), __main_block_copy_0, __main_block_dispose_0};
//入口
int main() {
//自动释放池，这里暂不管他
{__AtAutoreleasePool __autoreleasepool;
#ifdef NORMAL
__attribute__((__blocks__(byref))) __Block_byref_i_0 i;
i = {(void*)0,(__Block_byref_i_0 *)&i, 0, sizeof(__Block_byref_i_0), 1};
Block block1 = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_i_0 *)&i, 570425344));
((void (*)(__block_impl *))((__block_impl *)block1)->FuncPtr)((__block_impl *)block1);
#else
//定义一个__Block_byref_i_0结构体变量。并且初始化
__Block_byref_i_0 i;
i = {(void*)0,(__Block_byref_i_0 *)&i, 0, sizeof(__Block_byref_i_0), 1};
//定义一个__main_block_impl_0结构体变量，同时传入i的指针
__main_block_impl_0 tmp = __main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_i_0 *)&i, 570425344);
//把结构体变量的指针赋值给block1对象
Block block1 = &tmp;
//调用解耦固体。就是OC里面的`block1()`
((*block1->impl)->FuncPrt)(block1);
#endif
}
return 0;
}5 带全局变量、静态全局变量、局部全局变量类型的Block解析
从转换以前和转换以后的代码比较。发现__block变量和上面一样，这里就不做具体分析了。但是对于几个非__block变量则有不同情况：
全局变量
global_val和静态全局变量static_global_val转换以前和转换以后调用方式没有任何区别。局部静态变量
static_val会作为结构体__main_block_impl_0的一个属性。并且这个属性是局部静态变量的一个指针。当改变局部静态变量的值的时候，我们通过
__main_block_impl_0结构体的static_val属性拿到静态局部变量的指针，然后直接赋值。Block直接截取的值静态局部变量的指针。然后对指针操作。
int global_val = 1;
static int static_global_val = 2;
int main() {
@autoreleasepool {
__block int one = 1;
static int static_val = 2;
Block block1 = ^(){
one = 2;
global_val = global_val + 1;
static_global_val = static_global_val + 1;
static_val = static_val + 1;
printf("%d--%d--%d--%d",one,global_val,static_global_val,static_val);
};
block1();
}
return 0;
}
//==============上面是反编译以前的代码==================
typedef void (*Block)();
//全局变量和静态全局变量的用法没有任何转变。
int global_val = 1;
static int static_global_val = 2;
struct __block_impl {
void *isa;
int Flags;
int Reserved;
void *FuncPtr;
};
struct __Block_byref_one_0 {
void *__isa;
__Block_byref_one_0 *__forwarding;
int __flags;
int __size;
int one;
};
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
int *static_val;//局部静态变量的指针作为结构体的一个属性
__Block_byref_one_0 *one; // by ref
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int *_static_val, __Block_byref_one_0 *_one, int flags=0) : static_val(_static_val), one(_one->__forwarding) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
__Block_byref_one_0 *one = __cself->one; // bound by ref
int *static_val = __cself->static_val; // bound by copy
(one->__forwarding->one) = 2;
global_val = global_val + 1;
static_global_val = static_global_val + 1;
(*static_val) = (*static_val) + 1;
printf("%d--%d--%d--%d",(one->__forwarding->one),global_val,static_global_val,(*static_val));
}
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {
_Block_object_assign((void*)&dst->one, (void*)src->one, 8/*BLOCK_FIELD_IS_BYREF*/);
}
static void __main_block_dispose_0(struct __main_block_impl_0*src) {
_Block_object_dispose((void*)src->one, 8/*BLOCK_FIELD_IS_BYREF*/);
}
static struct __main_block_desc_0 {
size_t reserved;
size_t Block_size;
void (*copy)(struct __main_block_impl_0*, struct __main_block_impl_0*);
void (*dispose)(struct __main_block_impl_0*);
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0), __main_block_copy_0, __main_block_dispose_0};
int main() {
/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
__attribute__((__blocks__(byref))) __Block_byref_one_0 one = {(void*)0,(__Block_byref_one_0 *)&one, 0, sizeof(__Block_byref_one_0), 1};
static int static_val = 2;
//Block block1 = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, &static_val, (__Block_byref_one_0 *)&one, 570425344));
//上面这行转换为下面这行
__main_block_impl_0 tmp = __main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, &static_val, (__Block_byref_one_0 *)&one, 570425344);
Block block1 = (void (*)())&tmp;
((void (*)(__block_impl *))((__block_impl *)block1)->FuncPtr)((__block_impl *)block1);
}
return 0;
}6 总结
通过测试、我发现同一种类型的Block实例变量，会分别生成对应的__main_block_impl_X,__main_block_func_X,__main_block_desc_X,__main_block_copy_X,__main_block_dispose_X。但是会共用相同的__block_impl。如果多个Block(不管是不是同一种类型)使用同一个__block变量，则会共享相同的__Block_byref_YYY_X结构体。
把一个Block变量赋值给另一个Block变量。则相当于被复制的Block变量有两个引用，并不会生成一套对应的结构体。
判断Block是不是同一种类型，只与返回变量、参数类型相关。与通过宏定义的名字无关。
ios
**粗体** _斜体_ [链接](http://example.com) `代码` - 列表 > 引用。你还可以使用@来通知其他用户。