Blocks 概要
什么是 Block
block是能够截获自动变量(局部变量)的匿名函数
Blocks 模式
Block 语法
完整形式的 Block 语法与一般的 C 语言函数定义相比，仅有两点不同
- 没有函数名
- 带有'^'
通用说明
^ 返回值类型(void 可省略) 参数列表(void 可省略) 表达式
^int (int count) {
return count + 1;
}
^{printf("Blocks\n");}
Block 类型变量
C 语言可以将定义的函数的地址赋值给函数指针类型变量中
int func(int count)
{
return count + 1;
}
int (*funcptr) (int) = &func;
同样地，Block 语法下，可将 Block 语法生成的值赋值给 Block 类型的变量中。
int (^blk) (int);
和 C 语言相比，仅仅是把'*'变成'^',可以作为一下用途：
- 自动变量
- 函数参数
- 静态变量
- 静态全局变量
- 全局变量
//赋值
int (^blk1) (int) = ^int (int count) {
return count + 1;
};
int (^blk2) (int) = blk1;
blk = blk2;
//参数传递
void func (int (^blk) (int))
{
//do something
}
在函数参数和返回值中使用 Block类型的变量时，记述的方式十分复杂。这时使用 typedef 来简化
typedef int (^someBlk)(int);
/* 原来的记述方式
void func (int (^blk) (int))
*/
void func (someBlk blk)
{
//这样调用
blk(10);
}
Block 类型变量可以像 C 语言中的其他类型变量一样使用。
截获自动变量值
一开始我有说明Block是带有“自动变量的匿名函数”，那什么是带有自动变量值呢？举个例子
int main（）
{
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（）；
return 0；
}
执行结果会是 val = 10
执行结果并不是改写后的值，而是执行Block语法时的自动变量的瞬间值。该Block语法在执行时，字符串指标“cal = %d \n”被赋值到自动变量fmt中，int值被赋值到val中，因此这边值被保存（即被截获），而在执行时被使用。
这就是自动变量值的截获。
__block说明符
实际上，截获变量只能保存Block语法的瞬间值，保存后就不能改写该值。
这时，若想在Block语法的表达式中将值赋给Block语法外声明的自动变量，需要在该自动变量上附加__block。
使用附有__block说明符的自动变量可在Block中赋值，该变量称为__block变量。
Blocks 的实现
Block 本质
定义一个最简单block 打印hello world
int main(int argc, const char * argv[]) {
void (^block)() = ^{printf("Hello World!");};
block();
return 0;
}
使用clang指令
clang -rewrite-objc main.m
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!");}
你定义完block之后，其实是创建了一个函数，在创建结构体的时候把函数的指针一起传给了block，所以之后可以拿出来调用。
其实，Block 是转化为 Block 结构体类型的自动变量，类型定义如下。通过void *isa;,可以知道 Block 也是一个 OC 的对象，这就是 Block 的本质。
struct Block_descriptor {
unsigned long int reserved;
unsigned long int size;
void (*copy)(void *dst, void *src);
void (*dispose)(void *);
};
struct Block_layout {
void *isa;
int flags;
int reserved;
void (*invoke)(void *, ...);
struct Block_descriptor *descriptor;
/* Imported variables. */
};
值捕获的问题
int main(int argc, const char * argv[]) {
int a = 10;
void (^block)() = ^{printf("a = %d", a);};
block();
return 0;
}
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
int a;
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _a, int flags=0) : a(_a) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
int a = __cself->a; // bound by copy
printf("a = %d", a);}
定义block的时候，变量a的值就传递到了block结构体中，仅仅是值传递，所以在block中修改a是不会影响到外面的a变量的。
int main(int argc, const char * argv[]) {
__block int a = 10;
void (^block)() = ^{printf("a = %d", a);};
block();
return 0;
}
struct __Block_byref_a_0 {
void *__isa;
__Block_byref_a_0 *__forwarding;
int __flags;
int __size;
int a;
};
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
__Block_byref_a_0 *a; // by ref
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_a_0 *_a, int flags=0) : a(_a->__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_a_0 *a = __cself->a; // bound by ref
printf("a = %d", (a->__forwarding->a));}
__block 说明符类似于 static、auto 和 register 说明符，加了 __block 说明符以后，变量 a 变成了一个结构体实例，该结构体持有相当于原自动变量的成员变量，在像 block 内传递时把a->forwarding->a 的地址传过去了，所以在block内部便可以修改到外面的变量了。
Block 存储域
在之前的 C++ 的代码中有一行 ``` impl.isa = &_NSConcreteStackBlock;
根据isa指针，block一共有3种类型的block
* _NSConcreteGlobalBlock 全局静态，保存在数据.data 区域
* _NSConcreteStackBlock 保存在栈中，出函数作用域就销毁
* _NSConcreteMallocBlock 保存在堆中，retainCount == 0销毁
到现在的例子中都是使用的 _NSConcreteStackBlock 类，且都设置在栈上。
#### 【要点1】如果是定义在函数外面的block是global的，另外如果函数内部的block但是，没有捕获任何自动变量，那么它也是全局的。比如下面这样的代码：
typedef int (^blk_t)(int);
for(...){
blk_t blk = ^(int count) {return count;};
}
虽然，这个block在循环内，但是blk的地址总是不变的。说明这个block在全局段。
#### 【要点2】一种情况在非ARC下是无法编译的：
typedef int(^blk_t)(int);
blk_t func(int rate){
return ^(int count){return rate*count;}
}
这是因为：block捕获了栈上的rate自动变量，此时rate已经变成了一个结构体，而block中拥有这个结构体的指针。即如果返回block的话就是返回局部变量的指针。而这一点恰是编译器已经断定了。在ARC下没有这个问题，是因为ARC使用了autorelease了。
#### 【要点3】有时候我们需要调用block 的copy函数，将block拷贝到堆上。看下面的代码：
-(id) getBlockArray{
int val =10;
return [[NSArray alloc]initWithObjects:
^{NSLog(@"blk0:%d",val);},
^{NSLog(@"blk1:%d",val);},nil];
}
id obj = getBlockArray();
typedef void (^blk_t)(void);
blk_t blk = (blk_t){obj objectAtIndex:0};
blk();
这段代码在最后一行blk()会异常，因为数组中的block是栈上的。因为val是栈上的。解决办法就是调用copy方法。
#### 【要点4】不管block配置在何处，用copy方法复制都不会引起任何问题。在ARC环境下，如果不确定是否要copy block尽管copy即可。ARC会打扫战场。
注意：在栈上调用copy那么复制到堆上，在全局block调用copy什么也不做，在堆上调用block 引用计数增加
【注意】本人用Xcode 5.1.1 iOS sdk 7.1 编译发现：并非《Objective-C》高级编程这本书中描述的那样
int val肯定是在栈上的，我保存了val的地址，看看block调用前后是否变化。输出一致说明是栈上，不一致说明是堆上。
typedef int (^blkt1)(void) ;
-(void) stackOrHeap{
__block int val =10;
int valPtr = &val;//使用int的指针，来检测block到底在栈上，还是堆上
blkt1 s= ^{
NSLog(@"val_block = %d",++val);
return val;};
s();
NSLog(@"valPointer = %d",valPtr);
}
在ARC下——block捕获了自动变量，那么block就被会直接生成到堆上了。 val_block = 11 valPointer = 10
在非ARC下——block捕获了自动变量，该block还是在栈上的。 val_block = 11 valPointer = 11
调用copy之后的结果呢：
-(void) stackOrHeap{
__block int val =10;
int valPtr = &val;//使用int的指针，来检测block到底在栈上，还是堆上
blkt1 s= ^{
NSLog(@"val_block = %d",++val);
return val;};
blkt1 h = [s copy];
h();
NSLog(@"valPointer = %d",valPtr);
}
----------------在ARC下>>>>>>>>>>>无效果。 val_block = 11 valPointer = 10
----------------在非ARC下>>>>>>>>>确实复制到堆上了。 val_block = 11 valPointer = 10
用这个表格来表示，当block捕获了自动变量时候
| where block stay | ARC | 非ARC |
|------------------------|----------------|-------------|
| copy | heap | heap |
| no copy | heap | stack |
### __block变量存储区域
当block被复制到堆上时，他所捕获的对象、变量也全部复制到堆上。
回忆一下block捕获自动变量的时候，自动变量将编程一个结构体，结构体中有一个字段叫```__forwarding```，用于指向自动这个结构体。那么有了这个__forwarding指针，无论是栈上的block还是被拷贝到堆上，那么都会正确的访问自动变量的值。
### 截获对象
block会持有捕获的对象。编译器为了区分自动变量和对象，有一个类型来区分。
static void __main_block_copy_0(struct __main_block_impl_0 *dst, struct __main_block_impl_0 *src){
_Block_objct_assign(&dst->val,src->val,BLOCK_FIELD_IS_BYREF);
}
static void __main_block_dispose_0(struct __main_block_impl_0 *src){
_block_object_dispose(src->val,BLOCK_FIELD_IS_BYREF);
}
```BLOCK_FIELD_IS_BYREF```代表是变量。```BLOCK_FIELD_IS_OBJECT```代表是对象
__block修饰符可用于任何类型的自动变量
### 循环引用
根据上面讲的内容，block在持有对象的时候，对象如果持有block，会造成循环引用。解决办法有两种：
1. 使用__weak修饰符。id __weak obj = obj_
2. 使用__block修饰符。__block id tmp = self;然后在block中tmp = nil；这样就打破循环了。这个办法需要记得将tmp=nil。不推荐！
## 参考：
1. http://www.cnblogs.com/iOS-mt/p/4227336.html
2. 《Objective-C高级编程：iOS与OS X多线程和内存管理》
