[知其然知其所以然]－Block
什么是Block
Blocks 是C语言的扩充功能：带有自动变量( 局部变量)的匿名函数。
匿名函数
所谓匿名函数就是不带有名称的函数。C语言的标准不允许存在这样的函数。
int func(int count);
它声明了名称为func的函数。
int result = func(10);
调用函数func必须使用函数的名称func.
int result = (*funcptr)(10);
上面，使用函数指针来代替直接的函数调用，似乎不用知道函数名，也能使用该函数。但是，其实使用函数指针也仍然需要知道函数名。在赋值给函数指针时，若不使用想赋值的函数名称，就无法获得该函数的地址。
int (*funcptr)(int) = &func;
int result = (*funcptr)(10);
而通过Blocks，源代码中就能够使用匿名函数。
自动变量(局部变量)
C语言函数中可能使用的变量：
- 自动变量(局部变量)
- 函数的参数
- 静态变量(静态局部变量)
- 静态全局变量
- 全局变量
其中，在函数的多次调用之间能够传递值的变量有：
- 静态局部变量
- 静态全局变量
- 全局变量
虽然这些变量的作用域不同，但在整个程序当中，一个变量总保持在一个内存区域。因此，虽然多次调用函数，但该变量总能保持不变。在任何时候以任何状态调用，使用的都是同样的变量？值。、
int buttonId = 0;
void buttonCallack(int event){
printf("buttonId %d event=%d\n", buttonId, event);
}
如果只有一个按钮，那么该源代码毫无问题。可正常运行，但有多个按钮时会如何呢？
int buttonId = 0;
void buttonCallback(int event){
printf("buttonId %d event=%d\n", buttonId, event);
}
void setButtonCallbacks(){
for(int i = 0; i < BUTTON_MAX; ++i){
buttonId = i;
setButtonCallback(BUTTON_IDOFFSET + 1, &buttonCallback);
}
}
该源代码的问题很明显，全局变量buttonId只用一个，所有回调都适用for循环的最后的值。当然如果不是用全局变量，回调方将按钮ID作为函数参数传递，就能解决该问题。
void buttonCallback(int buttonId, int event){
printf("buttonId %d event=%d\n", buttonId, event);
}
但是，回调方在保持回调函数指针以为，还必须保持回调方的按钮ID。
C++和Objective-c使用类可保持变量值且能够多次持用该变量自身。它会声明持有成员变量的类，由类生成的实例或对象保持该成员变量的值。
@interface ButtonCallbackObject : NSObject
{
int buttondId_;
}
@implementation ButtonCallbackObject
- (id) initWithButtonId:(int)buttonId
{
self = [super init];
buttonId_ = buttonId;
return self;
}
- (void)callback:(int)event
{
NSLog(@"buttonId:%d event=%d\n", buttonId_, event);
}
@end
使用该类，由于对象保持按钮ID，因此回调方知需要保持对象即可：
void setButtonCallbacks(){
for(int i = 0; i < BUTTON_MAX; ++i){
ButtonCallbackObject *callbackObj = [ButtonCallbackObject alloc]initWithButtonId:i];
setButtonCallbackUsingObject(BUTTON_IDOFFSET, callbackObj);
}
}
由上可见，使用C++，OC的类增加了代码的长度。
这时我们就要用Blocks了。Blocks提供了类似由C++和OC类生成实例或对象来保持变量值的方法，其代码量与编写C语言函数差不多。
void setButtonCallbacks(){
for(int i = 0; i < BUTTON_MAX; ++i){
setButtonCallbackUsingBlock(BUTTON_IDOFFSET + i, ^(int event){
printf("buttonId:%d event=%d\n", i, event);
});
}
}
该源代码将带有自动变量i值的匿名函数设定为按钮的回调。
Blocks模式
Block 语法
上面例子的Block语法如下:
^(int event){
printf("buttonId:%d event:%d\n", i, event);
}
该Block语法使用了省略方式，其完整形式如下：
^void (int event){
printf("buttonId:%d event:%d\n", i, event);
}
如上所示，完整形式的Block语法与一般的C语言函数定义相比，仅有两点不同。
(1) 没有函数名。
(2) 带有"^"。
^ 返回值类型 参数列表 表达式
举例：
^ int (int count){return count + 1;}
省略形式：
^ 返回值类型 参数列表 表达式
省略返回值类型
^ 参数列表 表达式
省略返回值类型时：
- 如果表达式中有return 语句就使用该返回值的类型。
- 如果表达式中没有return语句，就使用void。
- 如果表达式中含有多个return语句时，所有return的返回值类型必须相同。
如果不使用参数，参数列表也可以省略。
^ 返回值类型 参数列表 表达式
省略后
^ 表达式
举例：
^void (void){printf("Blocks\n");}
省略后
^{printf("Blocks\n");}
Block 类型变量
C语言，将所定义函数的地址赋值给函数指针类型变量中。
int func(int count){
return count + 1;
}
int (*funcptr)(int) = &func;
这样一来，函数func的地址就能赋值给函数指针类型变量funcptr中了。
声明Block类型变量：
int (^blk)(int);
声明Block类型变量仅仅是将声明函数指针类型变量的"*"变为"^",该Block类型变量与一般的C语言变量完全相同。可作为：
- 自动变量
- 函数参数
- 静态变量
- 静态全局变量
- 全局变量
int (^blk)(int) = ^(int count){return count + 1;};
由Block类型变量向Block类型变量赋值。
int (^blk1)(int) = blk;
int (^blk2)(int);
blk2 = blk1;
Block 作为参数：
int func(int (^blk)(int)){
}
Block 作为返回值：
int (^func() (int))
{
return ^(int count){return count + 1;};
}
通过typedef，函数的定义变得会容易些。
typedef int (^blk_t)(int);
如上所示：通过使用typedef可声明blk_t类型变量。
上面例子可改为：
void func(int (^blk)(int))
改为：
void func(blk_t blk)
int (^func()(int))
改为
blk_t func()
调用Block
C函数指针调用，funcptr 为函数指针类型时，像下面这样调用函数指针类型变量：
int result = (*funcptr)(10)
变量blk为Block类型的情况下，这样调用Block类型变量：
int result = blk(10);
在函数参数中使用Block类型变量并执行Block
int func(blk_t blk, int rate){
return blk(rate);
}
在OC中使用：
- (int) methodUsingBlock:(blk_t)blk rate:(int)rate{
return blk(rate);
}
Block 类型变量可完全像通常的C语言变量一样使用，因此也可以使用指向Block类型变量的指针，即Block的指针类型变量。
typedef int (^blk_t)(int);
blk_t blk = ^(int count){return count + 1;};
blk_t *blkpt = &blk;
(*blkptr)(10);
由此可见Block变量可像C语言中其他类型变量一样使用。
截获自动变量值
int main(){
int dmy = 256;
int val = 10;
const char *fmt = "val = %d\n";
void (^blk)(void) = ^{
print(fmt, val);
}
val = 2;
fmt = "There values were changed. val = %d\n";
blk();
return 0;
}
执行结果是：val = 10
该源代码中，Block语法的表达式使用的是它之前声明的自动变量fmt 和 val。Blocks中，Block表达式截获所使用的自动变量的值，即保存该自动变量的瞬间值。执行结果并不是改写后的值"These values were changed. val = 2"。而是执行Block语法时的自动变量的瞬间值。该Block语法在执行时，字符串指针"val=%d\n"被赋值到自动变量fmt中，int值10被赋值到自动变量val中，因此这些值被保存(即被截获)，从而在执行块中使用。
__block 说明符
int val = 0;
void (^blk)(void) = ^{val = 1;};
blk();
printf("val = %d\n", val);
该源代码会产生编译错误：
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 说明符的自动变量可在Block中赋值。该变量称为 __block 变量。
截获的自动变量
如果将值赋值给Block中截获的自动变量，就会产生编译错误。
int val = 0;
void (^blk)(void) = ^{val = 1;};
该源代码会产生编译错误。
那么截获Objective－c对象，调用变更该对象的方法也会产生编译错误吗？
id array = [[NSMutableArray alloc] init];
void (^blk)(void) = ^{
id obj = [[NSObject alloc]init];
[array addObject:obj];
};
这是没有问题的，而向截获的变量array赋值则会产生编译错误。该源代码中截获的变量值为NSMutableArray 类对象。用C语言描述，即是截获NSMutableArray类对象用的结构体实例指针。虽然赋值给截获的自动变量array 的操作会产生编译错误。但使用截获的值却不会有任何问题。
id array = [[NSMutableArray alloc]init];
void (^blk)(void) = ^{
array = [[NSMutableArray alloc] init];
}
这样的操作会产生编译错误。应该为array添加__block 说明符
__block id array = [[NSMutableArray alloc]init];
void (^blk)(void) = ^{
array = [[NSMutableArray alloc] init];
}
使用C语言数组时必须小心使用其指针。
const char text[] = "hello";
void (^blk)(void) = ^{
printf("%c\n", text[2]);
}
上面代码会产生编译错误：
因为在现在的Blocks中，截获自动变量的方法并没有实现为C语言数组的截获，这时，使用指针可以解决该问题。
const char *text = "hello";
void (^blk)(void) = ^{
printf("%c\n", text[2]);
};
Blocks的实现
Block 的实质
Block 是 "带有自动变量的匿名函数"。
未完待续....
参考资料
《Objective-c 高级编程》
