简述
一句话搞懂block：可以理解为，block是对上下文代码段的打包，然后在适当的时机执行。
block长什么样
block语法和C语言的函数指针语法非常相似，比如函数指针的声明：
// C函数指针声明
// 返回值类型为int，有两个int型参数的函数指针
int (*ptr)(int, int);
typedef (*Ptr)(int, int);
而block把 * 换成了 ^ ：
// block声明
int (^func)(int, int);
typedef (^Func)(int, int);
编译器对block的处理
要深入block的底层原理，首先要知道编译器对block进行了什么样的处理，接下来一起看看。
1、在block.c文件中，简单编写以下代码：
#include <stdio.h>
int main () {
// 变量
int num = 0;
const char *str = "Hello World!";
// 定义block
void (^foo)(void) = ^{
int var1 = num + 1;
char var2 = str[0];
};
// 调用block
foo();
return 0;
}
2、把代码重写成c++，命令行使用：clang -rewrite-objc block.c，得到：
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
int num;
const char *str;
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _num, const char *_str, int flags=0) : num(_num), str(_str) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
int num = __cself->num; // bound by copy
const char *str = __cself->str; // bound by copy
int var1 = num + 1;
char var2 = str[0];
}
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 () {
int num = 0;
const char *str = "Hello World!";
void (*foo)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, num, str));
((void (*)(__block_impl *))((__block_impl *)foo)->FuncPtr)((__block_impl *)foo);
return 0;
}
static struct IMAGE_INFO { unsigned version; unsigned flag; } _OBJC_IMAGE_INFO = { 0, 2 };
分析block实现
1、首先，我们定义了变量：
int num = 0;
const char *str = "Hello World!";
2、然后第二步，定义block：
void (^foo)(void) = ^{
int var1 = num + 1;
char var2 = str[0];
};
它被重写成了：
void (*foo)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, num, str));
这里的__main_block_impl_0是什么呢？它是一个结构体，结构如下：
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
int num;
const char *str;
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _num, const char *_str, int flags=0) : num(_num), str(_str) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
从block的声明，重写之后代码中可以看到，它被处理成：调用__main_block_impl_0这个结构体构造方法，会把外层变量num、str传进来，赋值给结构体的成员变量。
OK。到这里，可以引伸出以下结论：
1) 当我们写一个block，实际上是写一个结构体
2) block的捕获特性。捕获变量，实际上是通过赋值给结构体的成员变量
3、接着第三步，调用block：
((void (*)(__block_impl *))((__block_impl *)foo)->FuncPtr)((__block_impl *)foo);
这里可以得知，block的调用，实际上是调用foo这个结构体里面的FuncPtr这个函数。
FuncPtr是在构造函数传递进来的，传进来的是__main_block_func_0这个函数地址。那么这个函数是什么呢？
在重写后的代码可以看到：
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
int num = __cself->num; // bound by copy
const char *str = __cself->str; // bound by copy
int var1 = num + 1;
char var2 = str[0];
}
其实到这里，我们已经可以得到以下结论：
当我们写一个block，实际上是写 一个结构体 + 一个静态函数。
结构体 - 负责捕获变量，
静态函数 - 在block被调用时，会调用这个静态函数。
补充
我们都知道，正常在block内是不能修改外层变量的（不加__block），比如：
int num = 0;
void (^foo)(void) = ^{
num = num + 1;
};
现在知道为什么了吧，因为以上代码相当于修改了捕获进来的变量，影响不了外层：
int num = 0;
void (^foo)(void) = ^{
int num_in_block = num; // 捕获进来
num_in_block = num_in_block + 1; // 修改的是捕获进来的变量num_in_block，而不是外层的num
};
如果加了__block之后，到底会起什么作用呢？ 尝试着动手试试吧 ~ 提前透露下，比如 __block int x，int 会被重写成结构体 struct_has_int_x 哟，interesting ~
