前言
很久前看了《Objective-C高级编程 iOS与OS X多线程和内存管理》这本书，但当时看起来晦涩难懂。最近利用下班时间重读了一遍，觉得还是得记录一下。毕竟往后阶段对相同的东西会有更深刻的理解。温故知新！
系列文章：
1、《Objective-C高级编程》温故知新之"自动引用计数"
2、《Objective-C高级编程》温故知新之"Blocks"
Blocks概要
Blocks 是C语言的扩充功能，即带有自动变量（局部变量）的匿名函数。
在计算机科学中，此概念也称为闭包(Closure)、lambda计算等。Swift中称作闭包
其他程序语言中 Block 的名称
浅显理解 Block
1、Block 语法
完整形式的 Block 语法与一般的C语言函数定义相比，仅有两点不同。
（1)没有函数名。
（2)带有“^”。
上面第一点也是匿名函数的由来。
Block 语法如下：
注意：Block 语法可以省略好几个项目。
1、返回值类型
省略返回值类型,如果表达式有 return 语句就使用该返回值的类型，如果表达式中没有 return 语句就使用 void 类型。 表达式中含有多个 return 语句时，所有 return 的返回值类型必须相同。相当于
省略返回值类型
2、如果没有参数，参数列表也可以省略。
省略参数列表
2、截获自动变量值
了解了匿名函数，接下来得了解“带有自动变量值得匿名函数”中的“带有自动变量值”的含义。
int dmy = 256;
int val = 10;
const char *fmt = "val = %d\n";
void (^blk)(void) = ^{
printf(fmt, val);
};
val = 2;
fmt = "These values were changed. val = %d\n";
blk();
打印：
val = 10
在调用blk前，改动了val,大家可能认为打印 val = 2,但实际上打印 val = 10;
该源码中，Block 语法表达式使用的是它之前声明的自动变量值为10的 val ，Block 表达式截获了这个值，并且保存下来，所以在执行 Block 语法后，即使在后面改写 Block 中使用的自动变量的值也不会影响 Block 执行时自动变量的值。
3、 __block 说明符
如果我们尝试修改截获的自动变量值，会怎么样，结果是会报错。
编译的时报“Variable is not assignable (missing __block type specifier)”
所以若要在 Block 语法的表达式中将值赋给在 Block 语法外声明的自动变量，需要在该自动变量上附加 __block 说明符
__block int val = 0;
void (^blk)(void) = ^{
val = 1;
};
blk();
printf("val = %d\n", val);
打印：
val = 1
注意：使用截获的值不会有问题，只有赋值才回报错。
深入理解 Block
1、Block 的实现
通过上篇系列文章讲到的 clang -rewrite-objc 将下列 Block 语句 转换为可读源码
void (^blk)(void) = ^{(printf("Block\n"));};
blk();
return 0;
我们先挑出部分可读源码：
显然，上面代码被转换成了下列源码
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
printf("Block\n");
}
该函数的参数 __cself 相当于 C++ 实例方法中指向实例自身的变量this, 或是 Objective-C 实例方法中指向对象自身的变量 self ，即参数 __cself 为指向 Block值的变量。
继续看源码中的参数 struct __main_block_impl_0 *__cself的声明
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结构体会变得非常简单。
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
};
第一个成员变量是 impl，看下 __block_impl impl的声明
struct __block_impl {
void *isa;
int Flags;
int Reserved;
void *FuncPtr;
};
我们从其名称可以联想到某些标志、今后版本升级所需的区域以及函数指针。这些会在后面详细说明。第二个成员是 Desc 指针，以下为其__main_block_desc_0结构体的声明。
static struct __main_block_desc_0 {
size_t reserved;
size_t Block_size;
}
如同其名称所示，其结构为今后版本升级所需的区域和 Block 的大小。
我们再回头看下初始化含有这些结构体的 __main_block_impl_0 结构体的构造函数。
__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;
}
进行讲解前，我们先看看构造函数的调用
void (*blk)(void) = ((void (*)())&__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);
第一个参数是由 Block 语法转换的 C 语言函数指针。第二个是参数是作为静态全局变量初始化的 __main_block_desc_0结构体实例指针。问我怎么知道，看下面源码啊：
static struct __main_block_func_0 __main_block_desc_0_DATA = {
0,
sizeof(struct __main_block_impl_0)
};
由此可知，该源码使用 Block，即__main_block_impl_0结构体实例的大小，进行初始化。
下面看看栈上的 __main_block_impl_0 结构体实例是如何根据这些参数进行初始化的。如果展开结构体__main_block_impl_0中的__block_impl结构体，可记述为如下形式：
struct __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int flags=0) {
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;
impl.Flags = 0;
impl.FuncPtr = __main_block_func_0;
Desc = &__main_block_desc_0_DATA;
}
从而，__main_block_impl_0构造函数已经足够清晰，除了_NSConcreteStackBlock仍未讲解，先看blk()的源码
((void (*)(__block_impl *))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk);
去掉转换部分为
(((__block_impl *)blk)->FuncPtr)((__block_impl *)blk);
这就是简单的使用函数指针调用函数。
那么一直没说的_NSConcreteStackBlock是什么呢？
首先，将 Block 指针赋给 Block 的结构体成员变量 isa .为了理解他，首先要理解 Objective-C 类和对象的实质。其实，所谓 Block 就是 Objective-C 对象。
id 这一变量类型用于存储 Objective-C 对象。在 Objective-C 源代码中，虽然可以像使用 void *类型那样随意使用 id, 但此 id 类型也能在 C 语言中声明。在 runtime.h 声明如下：
typedef struct objc_object {
Class isa;
} *id;
id 为 objc_object 结构体的指针类型。 然后再看下 Class
typedef struct objc_class *Class;
Class 为objc_class 结构体 的指针类型。objc_class 结构体声明如下：
struct objc_class {
Class isa;
};
这与 objc_object 结构体相同，所以
@interface MyObject : NSObject
{
int val0;
int val1;
}
上面代码基于 object_object 结构体，该类的对象的结构体如下：
struct MyObject {
Class isa;
int val0;
int val1;
};
可以看出，MyObject 类的实例变量 val0 和 val1 被声明为对象的结构体成员。 意味着，生成的各个对象，也就是“由该类生成的对象的各个结构体实例，通过成员变量 isa 保持该类的结构体实例指针”，如下图所示。
各类的结构体就是基于 objc_class 结构体的 class_t 结构体。class_t 结构体在 obj4 运行时库声明如下：
struct class_t {
struct class_t *isa;
struct class_t *superclass;
Cache cache;
IMP *vtable;
uintptr_t data_NEVER_USE;
};
回到之前的 Block 结构体，得知 _NSConcreteStackBlock，相当于 class_t 结构体实例。在将 Block 作为 Objective-C 的对象处理时，关于该类的信息放置于 _NSConcreteStackBlock，信息包含成员变量、方法名称、方法的实现（即函数指针）、属性以及父类的指针。
到此，我们已经了解 Block 的实质，知道 Block 即为 Objective-C 的对象了。
2、截获自动变量值
C代码
int dmy = 256;
int val = 10;
const char *fmt = "val = %d\n";
void (^blk)(void) = ^{
printf(fmt, val);
};
val = 2;
fmt = "These values were changed. val = %d\n";
blk();
源代码
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;
const char *fmt;
int val;
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, const char *_fmt, int _val, int flags=0) : fmt(_fmt), 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) {
const char *fmt = __cself->fmt; // bound by copy
int val = __cself->val; // bound by copy
z printf(fmt, val);
}
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, const char * argv[]) {
int dmy = 256;
int val = 10;
const char *fmt = "val = %d\n";
void (*blk)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, fmt, val));
val = 2;
fmt = "These values were changed. val = %d\n";
((void (*)(__block_impl *))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk);
return 0;
}
我们挑出部分代码
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
const char *fmt;
int val;
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
const char *fmt = __cself->fmt; // bound by copy
int val = __cself->val; // bound by copy
z printf(fmt, val);
}
从clang 编译后自带的注释得知是值复制,不是指针复制，不会受外界影响。再加上形参 __cself 是 block 自身，也就是说， val 值是执行block 内部语句时的值，也就是 10，这就是所谓的截获自动变量值原理。
3、__block 说明符
上面说到，添加__block 说明符则可以在 Block 内部修改截获的值，那原理是怎样的呢
C++代码
struct __Block_byref_val_0 {
void *__isa;
__Block_byref_val_0 *__forwarding;
int __flags;
int __size;
int val;
};
发现添加了__block 说明符，它竟然变成了结构体实例，结构体最后一个成员变量 val 相当于原自动变量。
Block 会被复制到堆上，即存储在堆上，所以外部变量也被复制到了堆上，我们对加了
__block关键字的外部变量进行操作，实际上是对已经被copy到了堆区的变量进行操作，而不是原来栈上的变量。如果不加__block，变量在 Block 内部只读
4、Block 存储域
Block 语法根据不同类型变量（下图的类是转换过后的类），存储的位置也不同。如下图：
1、_NSConcreteStackBlock
截获自动变量，上面讲得 Block 类都是 _NSConcreteStackBlock 类，存储在栈上。
2、_NSConcreteGlobalBlock
记述全局变量的地方使用 Block 语法时，生成的就是该类。存储在数据区域。
例如下列代码：
void (^blk)(void) = ^{ //此时将 Block 用结构体实例设置在程序的数据区域。
printf("Global Block\n");
};
int main(int argc, const char * argv[]) { ... }
3、_NSConcreteMallocBlock
在某种情况下，Block 会被复制到堆上，即存储在堆上。
例如下列代码：
/**对于引用了外部变量的Block，如果没有对他进行copy，*/
/**他的作用域只会在声明他的函数栈内（类型是__NSStackBlock__），*/
/**如果想在非ARC下直接返回此类Block，Xcode会提示编译错误的 */
typedef int(^MyBlock)();
MyBlock func()
{
//ARC
int i = 1;
return ^{ return i; };
}
/** ----------------------- */
typedef int(^MyBlock)();
MyBlock func()
{
//非ARC
int i = 1;
return [^{ return i; } copy]; 在这里修改一下就好了
}
