简述

一句话搞懂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 ~