block初体验
定义和使用block很简单：
int main(int argc, const char * argv[]) {
@autoreleasepool {
void(^sl_block)(int) = ^(int a1){
NSLog(@"aaaaa:%d",a1);
};
sl_block(12);
NSLog(@"Hello, World!");
}
return 0;
}
但是作为一个有理想的programmer，不仅要知道其怎么用，还要知道其内在原理。
揭开面纱
首先，将定义了上述block的main.m函数用clang 转换为main.cpp：
clang -rewrite-objc main.m
在同目录下会生成一个同名的.cpp文件。
打开cpp文件，找到main函数：
int main(int argc, const char * argv[]) {
/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
void(*sl_block)(int) = ((void (*)(int))&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA));
((void (*)(__block_impl *, int))((__block_impl *)sl_block)->FuncPtr)((__block_impl *)sl_block, 12);
NSLog((NSString *)&__NSConstantStringImpl__var_folders_l1_82ns1v1j2zs331rh8zrgd8l40000gn_T_main_3e93ec_mi_1);
}
return 0;
}
为了方便理解，先用typedef将其简化：
typedef void(*SL_BLOCK_TYPE)(int);
typedef void(*FuncPtr_TYPE)(__block_impl *, int);
int main(int argc, const char * argv[]) {
/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
SL_BLOCK_TYPE sl_block = SL_BLOCK_TYPE &__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA);
(FuncPtr_TYPE((__block_impl *)sl_block)->FuncPtr)((__block_impl *)sl_block, 12);
NSLog((NSString *)&__NSConstantStringImpl__var_folders_l1_82ns1v1j2zs331rh8zrgd8l40000gn_T_main_3e93ec_mi_1);
}
return 0;
}
先看第一句：
SL_BLOCK_TYPE sl_block = SL_BLOCK_TYPE &__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA);
找到其中的未知函数或者变量：__main_block_impl_0、__main_block_func_0、__main_block_desc_0_DATA，在文件中找到其定义。
先看__main_block_impl_0:
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;
}
};
可以看出，他是一个结构体，而上述__main_block_impl_0((void *, void *)是调用了其构造函数，返回一个__main_block_impl_0类型的结构体，并对该结构体取地址作为变量sl_block的值。
继续研究__main_block_impl_0结构体的内部定义，发现其包含另外两个结构体：
struct __block_impl impl;
struct __main_block_desc_0* Desc;
先看第一个，找到其具体定义：
struct __block_impl {
void *isa;
int Flags;
int Reserved;
void *FuncPtr;
};
这个好理解，就是简单的结构体，里面包含了两个int型数据和两个指针。为了理解，不在类型之间跳来跳去，直接__block_impl结构体消除，即将__main_block_impl_0结构体定义为：
struct __main_block_impl_0 {
// struct __block_impl impl;
void *isa;
int Flags;
int Reserved;
void *FuncPtr;
struct __main_block_desc_0* Desc;
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int flags=0) {
//impl.isa = &_NSConcreteStackBlock;
isa = &_NSConcreteStackBlock;
Flags = flags;
FuncPtr = fp;
Desc = desc;
}
};
然后看__main_block_desc_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)};
这里不仅定义了一个结构体，还定义并初始化了一个全局变量__main_block_desc_0_DATA。
因为这个结构体保存的信息为一个保留位reserved和block的size，就不做细研究。
__main_block_impl_0结构体解析完了，回到刚刚的位置，三个位置变量，两个（__main_block_impl_0、__main_block_desc_0_DATA）已经知道是什么了，还剩下一个__main_block_func_0。在文件中找到这个关键字的定义：
static void __main_block_func_0(struct __main_block_impl_0 *__cself, int a1) {
NSLog((NSString *)&__NSConstantStringImpl__var_folders_l1_82ns1v1j2zs331rh8zrgd8l40000gn_T_main_3e93ec_mi_0,a1);
}
很明显可以看出，这是一个函数，更确切的说，这就是block的实现部分。在sl_block的定义和赋值中可以看出，这个函数被当成参数传递给了及结构体__main_block_impl_0的构造函数，而结构体的构造函数中，又将该函数指针，赋值给了其成员变量FuncPtr。
到这里，基本就很明朗了：
定义一个block，实际上是定义了一个结构体，而block中要执行的代码，则被定义为一个函数，并且该函数的函数指针被结构体的FuncPtr成员所持有。
最后，看看block是怎么被调用的吧：
(FuncPtr_TYPE((__block_impl *)sl_block)->FuncPtr)((__block_impl *)sl_block, 12);
这个应该很容易就看出来了，就是函数指针的调用。取sl_block结构体中的FuncPtr成员，然后调用。
深入研究----捕捉外部变量
我们都知道，在block中，我们可以使用一些外部变量，那么，这就有一个问题了，block是怎么捕捉外部变量的呢？
将之前的main.m修改一下，再rewrite成cpp，细究。
main.m
int main(int argc, const char * argv[]) {
@autoreleasepool {
int i_a = 111;
int i_b = 222;
void(^sl_block)(int) = ^(int a1){
NSLog(@"%d==%d",i_a,i_b);
NSLog(@"aaaaa:%d",a1);
};
sl_block(12);
NSLog(@"Hello, World!");
}
return 0;
}
main.cpp
int main(int argc, const char * argv[]) {
/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
int i_a = 111;
int i_b = 222;
void(*sl_block)(int) = ((void (*)(int))&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, i_a, i_b));
((void (*)(__block_impl *, int))((__block_impl *)sl_block)->FuncPtr)((__block_impl *)sl_block, 12);
NSLog((NSString *)&__NSConstantStringImpl__var_folders_l1_82ns1v1j2zs331rh8zrgd8l40000gn_T_main_10456f_mi_2);
}
return 0;
}
可以看出，__main_block_impl_0构造函数的参数发生了变化，传递了两个参数：i_a,、i_b。
看看其结构体内部变化：
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
int i_a;
int i_b;
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _i_a, int _i_b, int flags=0) : i_a(_i_a), i_b(_i_b) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
结构体多了两个和外部变量同名同类型的成员变量。
再看其实现部分：
static void __main_block_func_0(struct __main_block_impl_0 *__cself, int a1) {
int i_a = __cself->i_a; // bound by copy
int i_b = __cself->i_b; // bound by copy
NSLog((NSString *)&__NSConstantStringImpl__var_folders_l1_82ns1v1j2zs331rh8zrgd8l40000gn_T_main_10456f_mi_0,i_a,i_b);
NSLog((NSString *)&__NSConstantStringImpl__var_folders_l1_82ns1v1j2zs331rh8zrgd8l40000gn_T_main_10456f_mi_1,a1);
}
可以看出，block内部使用的实际上不是外部变量，而是其成员变量，即外部变量的副本（bound by copy）。
综上所述，可以得出，block对于用到的外部变量，会将其保存为成员变量，以供block内部使用。
__block关键字
既然说到block对于外部变量的捕捉，就不得不提__block关键字。
对于上述的例子，外部变量对于block是readonly的。那么怎么才能readwrite呢？apple在设计block的时候肯定是早就考虑到了这个的，__block就是为了解决外部变量的write问题。
ps:在C语言的角度考虑这个问题
其实block的实现，基本都是基于c和c++的，所以考虑这个问题，很自然就想到了c语言的值传递和地址传递。（有兴趣可自行研究）
apple的实现
修改main.m，并rewrite成cpp：
int main(int argc, const char * argv[]) {
@autoreleasepool {
__block int i_a = 111;
int i_b = 222;
void(^sl_block)(int) = ^(int a1){
NSLog(@"%d==%d",i_a,i_b);
NSLog(@"aaaaa:%d",a1);
i_a= i_b + i_a;
};
sl_block(12);
NSLog(@"Hello, World!");
}
return 0;
}
int main(int argc, const char * argv[]) {
/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
__attribute__((__blocks__(byref))) __Block_byref_i_a_0 i_a = {(void*)0,(__Block_byref_i_a_0 *)&i_a, 0, sizeof(__Block_byref_i_a_0), 111};
int i_b = 222;
void(*sl_block)(int) = ((void (*)(int))&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, i_b, (__Block_byref_i_a_0 *)&i_a, 570425344));
((void (*)(__block_impl *, int))((__block_impl *)sl_block)->FuncPtr)((__block_impl *)sl_block, 12);
NSLog((NSString *)&__NSConstantStringImpl__var_folders_l1_82ns1v1j2zs331rh8zrgd8l40000gn_T_main_d79e13_mi_2);
}
return 0;
}
对比之前的，发现i_a变量，变成了一个结构体__Block_byref_i_a_0：
struct __Block_byref_i_a_0 {
void *__isa;
__Block_byref_i_a_0 *__forwarding;
int __flags;
int __size;
int i_a;
};
而且在传参的时候，也是变成了地址传递（(__Block_byref_i_a_0 *)&i_a,）。这就为修改i_a的值奠定了基础。因为地址传参之后修改的肯定不再是副本，而是本身。
再看看实现部分：
static void __main_block_func_0(struct __main_block_impl_0 *__cself, int a1) {
__Block_byref_i_a_0 *i_a = __cself->i_a; // bound by ref
int i_b = __cself->i_b; // bound by copy
NSLog((NSString *)&__NSConstantStringImpl__var_folders_l1_82ns1v1j2zs331rh8zrgd8l40000gn_T_main_d7c9ac_mi_0,(i_a->__forwarding->i_a),i_b);
NSLog((NSString *)&__NSConstantStringImpl__var_folders_l1_82ns1v1j2zs331rh8zrgd8l40000gn_T_main_d7c9ac_mi_1,a1);
(i_a->__forwarding->i_a)= i_b + (i_a->__forwarding->i_a);
}
到这里基本就明了了，__block修饰的变量，传递方式变成了地址传递，也就可以达到readwrite的效果了~
最后，(i_a->__forwarding->i_a)= i_b + (i_a->__forwarding->i_a);这个骚操作没搞懂，没有搞错的话，i_a和i_a->__forwarding是同一个地址。
__forwarding指向自身的操作，是因为block有可能存放在栈上，也有可能存放在堆上，当block没有发生复制时，它指向栈上的对象，当block发生复制时，block指向堆上的对象。