1.简介
从iOS4开始，苹果引入了这个C语言的扩充功能“Blocks”，在一些特定的场景下也是一把利刃。我前面一篇博客中初步介绍了Blocks这个东西，主要是语法的介绍（《iOS中Blocks的介绍》）。
我曾经看见了老外的一个系列的Blocks介绍，很有深度（A look inside blocks:Episode 1，A
look inside blocks:Episode 2， A look inside blocks:Episode 3），里面深入到汇编的层次对Blocks的实现进行了分析。不过如果象我这样对于汇编不熟悉的人肯定也是很多的，理解起来十分痛苦，于是就想到从ObjC本身对Blocks进行的处理里面来入手分析，看看对于Blocks都悄悄做了什么。
2.环境
很简单，就是Xcode啦。使用的编译器是CLang，主要是利用了-rewrite-objc这个参数，把源文件转换成中间文件。这样就揭开了面纱的一角。我使用的clang编译器版本是：
Apple clang version 4.0 (tags/Apple/clang-421.0.60) (based on LLVM 3.1svn)
Target: x86_64-apple-darwin12.5.0
Thread model: posix
转成中间文件的命令是:clang -rewrite-objc 源文件
3. 例子1
#include <stdio.h> int main(int argc, const char * argv[])
{
int val = 2;
int val1 = 5;
void (^blk)(void) = ^{printf("in Block():val=%d\n", val);}; val = 4;
blk();
printf("in main(): val=%d, val1=%d\n", val, val1);
return 0;
}
代码的运行结果是：
in Block():val=2
in main():val=4, val1=5
这里我们可以看到Block对于自动变量的“快照”功能。由于转成中间文件之后发现长了很多，变成了100多行（不同的clang版本转换出来的文件还不同，不过实现部分代码还是一样的），下面的代码是相关部分的节选，主要说明苹果是如何实现的。
struct __block_impl {
void *isa;
int Flags;
int Reserved;
void *FuncPtr;
};
#include <stdio.h>
int main(int, const char **);
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
int val;
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _val, int flags=0) : val(_val) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
int val = __cself->val; // bound by copy
printf("in Block():val=%d\n", val);}
static struct __main_block_desc_0 {
unsigned long reserved;
unsigned long Block_size;
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0)};
int main(int argc, const char * argv[])
{
int val = 2;
int val1 = 5;
void (*blk)(void) = (void (*)(void))&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, val);
val = 4;
((void (*)(struct __block_impl *))((struct __block_impl *)blk)->FuncPtr)((struct __block_impl *)blk);
printf("in main(): val=%d, val1=%d\n", val, val1);
return 0;
}
中间文件确实看起来复杂了不少，不过还是有脉络可循。
看main函数的内容，里面有个函数指针blk，这个就是指向Block的指针，所以难怪Block变量的声明和函数指针如此相像（就是把＊换成^），编译器转换后就是同一个东西啊。
我们看blk这个函数指针，就是__main_block_impl_0这个结构体变量的指针，这个结构体变量此时已经存在，然后用__main_block_func_0等几个变量赋初值。我们可以看到__main_block_impl_0这个struct中有个val这个项，并且在这里也赋值了，这就是给变量照的“快照”，由于这个变量在这里被记录了，所以无论外面的val变量如何变化，Block运行时使用的值就始终是“快照”的值了。同时我们也注意到__main_block_impl_0这个struct中没有val1这个项，所以说明如果Block中不用到的自动变量是不会自动加入到结构体中的。
Block的运行就是运行__main_block_impl_0这个struct中的FuncPtr这个指针，这个在前面初始化的时候已经被赋值成__main_block_func_0了，所以这里也就是运行这个函数，并把自己的指针传入。这里我们的实现非常简单，就是一句printf语句。
4.例子2
#include <stdio.h> int main(int argc, const char * argv[])
{
int __block val = 2;
int val1 = 5;
void (^blk)(void) = ^{printf("in Block():val=%d\n", ++val);}; blk();
printf("in main(): val=%d, val1=%d\n", val, val1);
return 0;
}
这个例子把自动变量val声明成了__block变量，这样语法上Block不是对val进行“快照”，而是会直接使用val变量，同时在Block内部val可读可写，不再是只读的了。
运行结果如下：
in Block():val=3
in main(): val=3, val1=5
同样展开成中间文件来看苹果的实现。
struct __block_impl {
void *isa;
int Flags;
int Reserved;
void *FuncPtr;
};
#include <stdio.h> int main(int, const char **);
struct __Block_byref_val_0 {
void *__isa;
__Block_byref_val_0 *__forwarding;
int __flags;
int __size;
int val;
}; struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
__Block_byref_val_0 *val; // by ref
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_val_0 *_val, int flags=0) : val(_val->__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_val_0 *val = __cself->val; // bound by ref
printf("in Block():val=%d\n", ++(val->__forwarding->val));}
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {_Block_object_assign((void*)&dst->val, (void*)src->val, 8/*BLOCK_FIELD_IS_BYREF*/);} static void __main_block_dispose_0(struct __main_block_impl_0*src) {_Block_object_dispose((void*)src->val, 8/*BLOCK_FIELD_IS_BYREF*/);} static struct __main_block_desc_0 {
unsigned long reserved;
unsigned long 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(int argc, const char * argv[])
{
__Block_byref_val_0 val = {(void*)0,(__Block_byref_val_0 *)&val, 0, sizeof(__Block_byref_val_0), 2};
int val1 = 5;
void (*blk)(void) = (void (*)(void))&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (struct __Block_byref_val_0 *)&val, 570425344); ((void (*)(struct __block_impl *))((struct __block_impl *)blk)->FuncPtr)((struct __block_impl *)blk);
printf("in main(): val=%d, val1=%d\n", (val.__forwarding->val), val1);
return 0;
}
中间文件又变长了一些，除去我们已经了解的部分，我们可以看到自动变量val不再是直接加入到__main_block_impl_0里面，而是又变成了一个__Block_byref_val_0的struct结构体的指针。
main函数里面对于val的赋值已经变成了对这样一个数据结构的赋值，第一句上就把2赋给了__Block_byref_val_0里面的val项，然后在blk这个指针初始化的时候，把__Block_byref_val_0的结构体变量指针传入__main_block_impl_0。此后所有对于自动变量val的操作都变成对val.__forwarding->val的操作。这样就解决了Block内外变量同时变化的问题（在操作同一块内存）。
这里还看见__Block_byref_val_0里面有个__forwarding项，这个项是指向自身的一根指针。在blk指针初始化的时候我们把这个指针的值传入了__main_block_impl_0。
在__main_block_desc_0里面，多出了两个函数指针，分别用于copy和dispose，这两个函数这里也是自动生成的。
5.总结
综合前面的例子来看，Block的实现还是借助了C语言的函数指针来实现了，对于普通的自动变量，在Block声明时会快照内容存储；对于__block变量，则是生成一个数据结构来存储，然后取代所有访问这个变量的地方。
事实上，因为Block运行时完全可能自动变量的生命周期已经结束，所以Block对于内存的管理是很复杂的，会把内容从栈上copy到堆上（这也是copy和dispose函数的作用）。所以Block虽然威力巨大，但使用时也需要遵循一定的规则。