通过下面几个例子，探讨 block 是如何实现的：

例子1：

1
2
3
4
5
6
7
8
#include <stdio.h>
int main()
{
  void (^blk)(void) = ^{
    printf("Hello, World!\n");
  };
  return 0;
}

为了研究编译器是如何实现 block 的，我们需要使用 clang。clang 提供一个命令，可以将 Objetive-C 的源码改写成 c 语言的，借此可以研究 block 具体的源码实现方式：

1
clang -rewrite-objc block.c

转化之后，生成 block.app：

1
2
3
4
5
6
struct __block_impl {
  void *isa;
  int Flags;
  int Reserved;
  void *FuncPtr;
};

从结构体的命名可以看出这是 block 的实现，block 在 clang 编译器编译之后，生成了一个 __block_impl 结构体，isa 指针表明了 block 可以是一个对象，而 FuncPtr 指针保存了 block 函数的调用地址。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
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 void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  printf("Hello, World!\n");
}

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;
}

下面我们就具体看一下是如何实现的，__main_block_impl_0 就是该 block 的实现，从中我们可以看出：

  • __main_block_impl_0 中包含了两个成员变量和一个构造函数，成员变量分别是 __block_impl 结构体和描述信息。
  • __block_impl 结构体，isa 指针证明 block 是一个对象。FuncPtr 保存了 block 的调用地址。
  • __main_block_desc_0 结构体，其中 Block_size 存储 block 大小。

从上面代码，可以看出执行 block 就是调用一个以 block 自身作为参数的函数，这个函数对应着 block 的执行体。

例子2：

block 如何捕获局部变量

1
2
3
4
5
6
7
8
9
int main()
{
  int i = 1024;
  void (^blk)(void) = ^{
    printf("%d",i);
  };
  blk();
  return 0;
}

通过 clang 编译之后：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  int i;
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _i, int flags=0) : i(_i) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  int i = __cself->i; // bound by copy
  printf("%d",i);
}

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 i = 1024;
    void (*blk)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, i));
    ((void (*)(__block_impl *))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk);
    return 0;
}

从中可以看出这次的 block 结构体 __main_block_impl_0 多了个成员变量 i ，用来存储使用到的局部变量 i，此时可以看到 __cself 参数的作用，类似 C++ 中的 this 和 Objective-C 的 self 当在 block 中引用的变量 i 的时候，实际是在声明 block 时，被 copy 到 __main_block_impl_0 结构体中的那个成员变量 i，并且把 __cself 指针指向成员变量 i。

如果尝试修改局部变量，编译会报错：

图示

错误原因告诉我们变量不可赋值，也提醒我们要使用__block类型标识符。

因为局部变量 i 是在 main 函数内部声明的，说明 i 的内存存在于 main 函数的栈空间内部，但是 block 内部的代码在 __main_block_func_0 函数内部。__main_block_func_0 函数内部无法访问 i 变量的内存空间，两个函数的栈空间不一样，__main_block_func_0 内部拿到的 i 是 block 结构体内部的 i，main 函数中的局部变量 i 和函数 __main_block_func_0 不在同一个作用域中，调用过程中只是进行了值传递。因此无法在 __main_block_func_0 函数内部去修改 main 函数内部的变量。

当然，在上面代码中，我们可以通过指针来实现局部变量的修改。不过这是由于在调用 __main_block_func_0 时，main 函数栈还没展开完成，变量 i 还在栈中。但是在很多情况下，block 是作为参数传递以供后续回调执行的。通常在这些情况下，block 被执行时，定义时所在的函数栈已经被展开，局部变量已经不在栈中了已经被销毁了，再用指针访问就会报常见的坏内存访问。

例子3：

静态局部变量是如何在 __block 执行体中被修改的。

1
2
3
4
5
6
7
8
9
int main(int argc, char * argv[]) {
    static int i = 10;
    void (^blk)(void) = ^{
        i = 30;
        printf("%d", i);
    };
    blk();
    return 0;
}

通过 clang 编译之后：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  int *i;
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int *_i, int flags=0) : i(_i) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  int *i = __cself->i; // bound by copy

        (*i) = 30;
        printf("%d", (*i));
    }

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 argc, char * argv[]) {
    static int i = 10;
    void (*blk)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, &i));
    ((void (*)(__block_impl *))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk);
    return 0;
}

从中可以看出这次的 block 结构体 __main_block_impl_0 成员变量 i 存储的是变量的地址，上面中间代码片段与前一个片段的差别主要在于 main 函数里传递的是 i 的地址(&i)，以及 __main_block_impl_0 结构体中成员 i 变成指针类型(int *)。
然后在执行 block 时，通过指针修改值。

block 访问局部变量，会自动捕获到 block 内部，局部变量是通过值传递的形式，用 static 修饰的局部变量是通过指针传递的形式
局部变量离开作用域，存在随时被销毁的风险，所以 block 会通过值传递的形式，自动捕获到 block 内部。
因为静态局部变量存在于数据段中，不存在栈展开后非法访存的风险。

当然，全局变量、静态全局变量都可以在 block 里面被修改，直接访问，不会捕获到 block 内部。

例子4：

__block 类型变量是如何支持修改。
int 类型变量加上__block指示符，使得变量 i 可以在 block 函数体中被修改：

1
2
3
4
5
6
7
8
9
10
int main()
{
    __block int i = 1024;
    void (^blk)(void) = ^{
        i = 1023;
        printf("%d",i);
    };
    blk();
    return 0;
}

通过 clang 编译之后：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
struct __Block_byref_i_0 {
  void *__isa;
__Block_byref_i_0 *__forwarding;
 int __flags;
 int __size;
 int i;
};

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  __Block_byref_i_0 *i; // by ref
  __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;
  }
};

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) = 1023;
  printf("%d",(i->__forwarding->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*/);}

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*);
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0), __main_block_copy_0, __main_block_dispose_0};

int main()
{
    __attribute__((__blocks__(byref))) __Block_byref_i_0 i = {(void*)0,(__Block_byref_i_0 *)&i, 0, sizeof(__Block_byref_i_0), 1024};
    void (*blk)(void) = ((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 *)blk)->FuncPtr)((__block_impl *)blk);
    return 0;
}

用 __block 修饰变量，编译器会将 __block 修饰的变量包装成一个对象。
首先被 __block 修饰的 i 变量声明变为名为 i 的 __Block_byref_i_0 结构体，也就是说加上 __block 修饰的话捕获到的 block 内的变量为 __Block_byref_i_0 类型的结构体。

1
2
3
4
5
6
7
struct __Block_byref_i_0 {
  void *__isa;
__Block_byref_i_0 *__forwarding;
 int __flags;
 int __size;
 int i;
};
  • __isa：__Block_byref_i_0 中也有 isa 指针也就是说 __Block_byref_i_0 本质也一个对象。
  • __forwarding：__forwarding 是 __Block_byref_i_0 结构体类型的，并且 __forwarding 存储的值为 (__Block_byref_i_0 *)&i，即结构体自己的内存地址。
  • i：用来存储使用到的局部变量 i。

__main_block_impl_0 对应的结构体：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  __Block_byref_i_0 *i; // by ref
  __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;
  }
};

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) = 1023;
  printf("%d",(i->__forwarding->i));
}
  • __main_block_impl_0 的成员变量 i 变成了 __Block_byref_i_0* 指针类型。
  • __Block_byref_i_0 指针类型变量 i，通过其成员变量 __forwarding 指针来操作另一个成员变量。

之后调用 block，首先取出 __main_block_impl_0 中的 i，通过 __Block_byref_i_0 结构体拿到 __forwarding 指针，上面提到过 __forwarding 中保存的就是 __Block_byref_i_0 结构体本身，在通过 __forwarding 拿到结构体中的 i 变量并修改其值。

到此为止，__block 为什么能修改变量的值已经很清晰了。__block 将变量包装成对象，然后在把变量封装在结构体里面，block 内部存储的变量为结构体指针，也就可以通过指针找到内存地址进而修改变量的值。