Block的实质
Block的定义是带有自动变量的匿名函数，下面从源码的角度探究下Block究竟是什么
下面是一个Block的简单实现：
int main(int argc, const char * argv[]) {@autoreleasepool {// insert code here...void (^blk)(void) = ^{printf("Block\n");};blk();}return 0;
}通过clang编译器转换为如下的C++代码：
// 定义Block的实现结构体
struct __block_impl {void *isa; // 指向所属类的指针int Flags; // 标志性参数，暂时没用到所以默认为0int Reserved; // 今后版本升级所需的区域大小。void *FuncPtr; // 函数指针，指向实际执行的函数，也就是Block中花括号里面的代码内容。
};// 定义具体的Block结构体
struct __main_block_impl_0 {struct __block_impl impl; // 上面定义的Block实现结构体的变量struct __main_block_desc_0* Desc; // Block描述符的指针// 构造函数__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; // 设置Block的执行函数指针Desc = desc; // 设置Block的描述符}
};// Block的实际执行函数
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {printf("Block\n"); // Block执行时输出的内容
}// Block描述符结构体
static struct __main_block_desc_0 {size_t reserved; // 今后版本升级所需区域的大小（一般填0）size_t Block_size; // Block的大小
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0) }; // 初始化Block描述符// 主函数
int main(int argc, const char * argv[]) {// 创建Blockvoid (*blk)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA));// 调用Block((void (*)(__block_impl *))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk);return 0;
}
可以看到^{printf("Block\n");转换成了
// Block的实际执行函数
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {printf("Block\n"); // Block执行时输出的内容
}
block的匿名函数被转换成普通C语言函数，函数命名按照block语法所属的函数名（此处为main函数）和在该函数中出现的顺序（此处为0）。
这里的_ self相当于OC中的指向对象自身的self，也就是_ self指向block值的变量
_ self参数是__main_block_impl_0的参数
__main_block_impl_0
// 定义具体的Block结构体
struct __main_block_impl_0 {struct __block_impl impl; // 上面定义的Block实现结构体的变量struct __main_block_desc_0* Desc; // Block描述符的指针// 构造函数__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; // 设置Block的执行函数指针Desc = desc; // 设置Block的描述符}
};
这里主要定义类两个结构体，第一个成员是__block_impl 结构体，第二个是__main_block_desc_0,和实现构造函数
__block_impl
struct __block_impl {void *isa;//指向所属类的指针int Flags;//标志性参数，暂时没用到所以默认为0int Reserved;//今后版本升级所需的区域大小。void *FuncPtr;//函数指针，指向实际执行的函数，也就是block中花括号里面的代码内容。
};如果block变量为空的话，这里的FuncPtr指针就会指向错误的地址而不是实际执行的函数，此时就会报错。
__main_block_desc_0
static struct __main_block_desc_0 {size_t reserved; //今后版本升级所需区域的大小（一般填0）size_t Block_size; //Block的大小
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0)};第一个成员变量指的是今后版本升级所需区域的大小（一般填0）。
第二个成员变量是Block的大小。
__main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0)};：
-
这就是和我们平时用结构体一样，在定义完最后写一个结构体实例变量，变量名就是__main_block_desc_0_DATA。
-
其中reserved为0，Block_size是sizeof(struct __main_block_impl_0)。
__main_block_impl_0（）构造函数
__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;}在这个结构体的构造函数里，isa指针保持这所属类的结构体的实例的指针。_mainblockimlp0结构体就相当于Objective-C类对象的结构体，这里的_NSConcreteStackBlock相当于Block的结构体实例,也就是说block其实就是Objective-C对于闭包的对象实现。
main函数
// 主函数
int main(int argc, const char * argv[]) {// 创建Block// 使用类型转换将Block结构体的地址转换成函数指针类型void (*blk)(void) = // 将Block结构体转换为函数指针类型((void (*)())&__main_block_impl_0(// Block的执行函数指针(void *)__main_block_func_0, // Block描述符的地址&__main_block_desc_0_DATA));// 调用Block// 获取Block结构体中的FuncPtr成员，并进行必要的类型转换后调用((void (*)(__block_impl *))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk);return 0;
}
第一部分是将__main_block_impl_0结构体类型的自动变量，也就是栈上生成的__main_block_impl_0结构体实例的指针，赋值给__main_block_impl_0结构体指针类型的变量blk。
第二部分是相当于源代码中的blk()，即使用该Block部分。去掉转换部分就是：
(*blk->impl.FuncPtr)(blk);使用函数指针调用函数。由Block语法转换的__main_block_impl_0函数的指针被赋值成员变量FunPtr中。
Block捕获机制
block变量捕获就是在执行Block语法的时候，Block语法表达式所使用的自动变量的值是被保存进了Block的结构体实例中，也就是Block自身中。
如果Block外面还有很多自动变量，静态变，这些变量在Block里面并不会被使用到。那么这些变量并不会被Block捕获进来，也就是说并不会在构造函数里面传入它们的值。
为了保证block内部能够正常访问外部的变量，block有个变量捕获机制
下面是对于不同变量时Block的捕获：
- 全局变量： 不捕获
- 局部变量： 捕获值
- 静态全局变量： 不捕获
- 静态局部变量： 捕获指针
- const修饰的局部常量：捕获值
- const修饰的静态局部常量：捕获指针
当Block捕获的是变量的值时，在block内部不能修改变量，当Block捕获的是变量的指针时，在block内部可以修改变量
对于全局变量Block是进行直接访问的
全局变量：
int max = 3;
int main(int argc, const char * argv[]) {@autoreleasepool {// insert code here...void (^blk)(void) = ^{printf("%d\n", max);};max = 60;blk();}return 0;
}
局部变量：
int dmy = 256;int val = 10;const char *fmt = "val = %d\n";void (^blk)(void) = ^{printf(fmt, val);};val = 2;fmt = "These values were changed. val = %d\n";blk();
静态全局变量
static int max = 3;
int main(int argc, const char * argv[]) {@autoreleasepool {// insert code here...void (^blk)(void) = ^{printf("%d\n", max);};max = 60;blk();}return 0;
}
静态局部变量
static int val = 10;const char *fmt = "val = %d\n";void (^blk)(void) = ^{val = 2;printf(fmt, val);};fmt = "These values were changed. val = %d\n";blk();
Block捕获普通变量
int main(int argc, const char * argv[]) {int dmy = 256;int val = 10;const char *fmt = "val = %d\n";void (^blk)(void) = ^{printf(fmt, val);};blk();return 0;
}
转化后的代码：
// Block结构体定义
struct __block_impl {void *isa; // 指向Block类型的标识int Flags; // Block标志位int Reserved; // 保留字段void *FuncPtr; // 指向Block执行函数的指针
};// 定义特定于main函数的Block实现
struct __main_block_impl_0 {struct __block_impl impl; // 包含Block的基本实现struct __main_block_desc_0* Desc; // 指向Block描述符const char *fmt; // 格式字符串int val; // 值// 构造函数__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, const char *_fmt, int _val, int flags = 0): fmt(_fmt), val(_val) { // 初始化成员变量impl.isa = &_NSConcreteStackBlock; // 设置Block类型标识impl.Flags = flags; // 设置Block标志位impl.FuncPtr = fp; // 设置Block执行函数的指针Desc = desc; // 设置Block描述符}
};// Block执行函数
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {const char *fmt = __cself->fmt; // 获取格式字符串int val = __cself->val; // 获取值printf(fmt, val); // 执行打印操作
}// Block描述符
static struct __main_block_desc_0 {size_t reserved; // 保留字段size_t Block_size; // Block的大小
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0) };// 主函数
int main(int argc, const char * argv[]) {int dmy = 256; // 未使用的变量int val = 10; // 用于输出的整数值const char *fmt = "val = %d\n"; // 输出格式字符串// 创建Blockvoid (*blk)(void) = // 类型转换为函数指针((void (*)())&__main_block_impl_0(// Block执行函数指针(void *)__main_block_func_0, // Block描述符地址&__main_block_desc_0_DATA, // 格式字符串fmt, // 用于输出的整数值val));return 0;
}
与上次不同的是在block内部语法表达式中使用的自动变量（fmt，val）被作为成员变量追加到了_mainblockimpl0结构体中（注意：block没有使用的自动变量不会被追加，如dmy变量）。
struct __main_block_impl_0 {struct __block_impl impl; // 包含Block的基本实现struct __main_block_desc_0* Desc; // 指向Block描述符const char *fmt; // 格式字符串int val; // 值// 构造函数__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, const char *_fmt, int _val, int flags = 0): fmt(_fmt), val(_val) { // 初始化成员变量impl.isa = &_NSConcreteStackBlock; // 设置Block类型标识impl.Flags = flags; // 设置Block标志位impl.FuncPtr = fp; // 设置Block执行函数的指针Desc = desc; // 设置Block描述符}
};
在Block执行函数中,fmt,var都是从__cself里面获取的，更说明了二者是属于block的.
这两个变量是值传递，而不是指针传递，也就是说Block仅仅截获自动变量的值，所以这就解释了即使改变了外部的自动变量的值，也不会影响Block内部的值。
// Block执行函数
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {const char *fmt = __cself->fmt; // 获取格式字符串int val = __cself->val; // 获取值printf(fmt, val); // 执行打印操作
}
Block捕获_ _block修饰的变量
编译器会将_ _block修饰的变量包装成一个对象，变成对象后就可以根据指针地址在block内部去修改外部的变量,block通过**__forwarding**指针去修改变量的值
int main(int argc, const char * argv[]) {__block int val = 10;void (^blk)(void) = ^{val = 1;};return 0;
}转换后的代码：
//__block说明符修饰后的变量的结构体
struct __Block_byref_val_0 {void *__isa; //指向所属类的指针__Block_byref_val_0 *__forwarding; //指向自己的内存地址的指针int __flags; //标志性参数，暂时没用到所以默认为0int __size; //该结构体所占用的大小int val; //该结构体存储的值，即原变量的赋的值
};//block本体
struct __main_block_impl_0 {struct __block_impl impl; //block的主体struct __main block desc 0* Desc; //存储该block的大小__Block_byref_val_0 *val; //__block修饰的变量的值//构造函数__main_block_impl_0(void *fp, struct __main_block_desc 0 *desc, __Block_byrefval_0 *_val, int flags=0) : val(_val->__forwarding) {impl.isa = &_NSConcreteStackBlock;impl.Flags = flags;impl.FuncPtr = fp;Desc = desc;
};//封装的block逻辑，存储了block的代码块
static void __main_block_func_0(struct__main_block_impl_0 *_cself) {__Block_byref_val_0 *val =__cself->val;(val->__forwarding->val) = 1;
}
static void_main_block_copy_0(struct __main_block_impl_0* dst, struct __main_block_impl_0* src) {//根据auto变量的修饰符（__strong、__weak、__unsafe_unretained）做出相应的操作，形成强引用（retain）或者弱引用_Block_object_assign(&dst->val, src->val, BLOCK_FIELD_IS_BYREF);
}static void __main_block_dispose_0(struct __main_block_imp1_0* src) {//自动释放引用的auto变量（相当于release）_Block_object_dispose(src->val, BLOCK_FIELD_IS_BYREF);
}static struct __main_block_desc_0 {unsigned long reserved; //保留字段unsigned long Block_size; //block大小void (*copy)(struct __main_block_impl_0*, struct __main_block_impl_0*); //copy的函数指针，下面使用构造函数进行了初始化void (*dispose)(struct __main_block_impl_0*); //dispose的函数指针，下面使用构造函数进行了初始化
}//构造函数，初始化保留字段、block大小及两个函数__main_block_desc_0_DATA = {0,sizeof(structmain_block_impl_0),__main_block_copy_O, __main_block_dispose_0
};
int main() {//之前的 __block int val = 10;变成了结构体实例struct __Block_byref_val_0 val = {0, //isa指针&val, //指向自身地址的指针0, //标志变量sizeof(__Block_byref_val_0), //block大小10 //该数据的值};blk = &__main_block_impl_0(
__main_block_func_0, &__main_block_desc_0_DATA, &val, 0x22000000);return 0;
}通过源代码发现__block说明符修饰的变量的结构体__多了个指针_ _Block_byref_val_0 *__forwarding,指向自己的内存地址的指针
struct __Block_byref_val_0 {void *__isa; //指向所属类的指针__Block_byref_val_0 *__forwarding; //指向自己的内存地址的指针int __flags; //标志性参数，暂时没用到所以默认为0int __size; //该结构体所占用的大小int val; //该结构体存储的值，即原变量的赋的值
};
在__main_block_func_0打印的并不是_ _Block_byref_val_0* val而是(val->__forwarding->val)并且 _ _block说明符修饰的变量变成了一个结构体
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {__Block_byref_val_0 *val = __cself->val; (val->__forwarding->val) = 1;printf("val = %d\n", (val->__forwarding->val));
}那么为什么会有成员变量__forwarding呢？__
因为__block变量用结构体成员变量__forwarding可以实现无论__block变量配置在栈上还是堆上时都能够正确的访问__block变量。
总结
- Block的本质是一个对象，其内部的第一个成员是isa指针，通过内部的FuncPtr指针指向实际执行的函数，也就是Block中花括号里面的代码内容。
- Block只会捕获自己需要使用的自动变量并将其保存进了Block的结构体实例中，也就是Block自身中。
- Block捕获普通的局部变量只是通过构造函数将它的值传递进了Block的结构体实例中的成员，因此不能在Block内部修改值，并且在Block外修改的值也不会影响Block捕获时的值
- Block捕获static修饰的局部变量是捕获它的指针，因此可以在Block内部修改值
- Block捕获_ _Block变量时会将其转换成结构体并且生成
_ _Block_byref_val_0 *__forwarding指针,指向自己的内存地址的指针，通过该指针就能访问和修改 _ _Blcok变量
![Could not install packages due to an EnvironmentError: [WinError 5]](https://img-blog.csdnimg.cn/direct/df413fc3bbea46f7962bc7fe31fa6a01.png)
