Blocks概要

什么是Blocks？

Blocks可简单概括为：

带有自动变量（局部变量）的匿名函数

在使用Blocks时，可以不声明C++类和Objective-C类，也没有使用静态变量、静态全局变量或全局变量时的问题，仅用编写C语言函数的源代码量即可使用带有自动变量值的匿名函数。

对于“带有自动变量值的匿名函数”这一概念并不仅指Blocks。它还存在于许多其他程序语言中。在计算机科学中，此概念也称为闭包（Closure）、lambda计算（λ计算）等。

Block语法

完整的Block语法与一般的C语言函数定义相比，仅有两点不同。

1. 没有函数名
2. 带有“^”

^：
由于OS X、iOS应用程序的源代码中将大量使用Block，所以插入该记号便于查找。

例如可写出下面形式的Block语法：

^int (int count) {return count + 1;}

当省略返回值类型时：

^(int count) {return count + 1;}

省略返回值类型时，如果表达式中与return语句就使用该返回值的类型；如果没有return语句就使用void类型；当表达式中含有多个return语句时，所有return的返回值类型必须相同。

如果不使用参数，参数列表也可省略：

^void (void) {printf("Blocks\n");}

上述代码可以省略为：

^{printf("Blocks\n");}

Block类型变量

声明block类型变量的实例如下：

int (^blk) (int);

使用block语法将Block赋值给Block类型变量：

int (^blk) (int) = ^int (int count) {return count + 1;};

由"^"开始的 Block 语法生成的 Block 被赋值给变量 blk 中。因为与通常的变量相同，所以当然也可以由Block类型变量向 Block 类型变量赋值:

int(^blk1)(int) = blk;
int (^blk2)(int);
blk2 = blk1;

在函数参数中使用 Block类型变量可以向函数传递 Block。

void func(int (^blk)(int)) {//...}

在函数返回值中指定 Block 类型，可以将 Block 作为函数的返回值返回。

int (^func()(int))
	return ^(int count){return count + 1;};
}

由此可知，在函数参数和返回值中使用 Block 类型变量时，记述方式极为复杂。这时，我们可以像使用函数指针类型时那样，使用 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类型变量调用Block与C语言通常的函数调用没有区别。在函数参数中使用Block类型变量并在函数中执行 Block 的例子如下：

int func(blk_t blk,int rate) {
	return blk (rate);
}

当然，在 Objective-C的方法中也可使用。

-(int) methodUsingBlock:(blk_t)blk rate:(int)rate {
	return blk (rate);
}

截获自动变量值

int main() {
	int dmy = 256;
	int val = 10;
	const char *fmt = "val = 号d\n";
	void (^b1k)(void) = ^{printf(fmt,val);};
	val = 2;
	fmt = "These values were changed. val = %d\n";
	blk();
	return 0;
}

结果是

val= 10

执行结果并不是改写后的值"These values were changed. val=2"，而是执行 Block 语法时的自动变量的瞬间值。该Block语法在执行时，字符串指针"val=%d\n"被赋值到自动变量 fmt中，int 值10被赋值到自动变量 val中，因此这些值被保存（即被截获），从而在执行块时使用。
这就是自动变量值的截获。

__block说明符

实际上，自动变量值截获只能保存执行 Block 语法瞬间的值。保存后就不能改写该值。下面我们来尝试改写截获的自动变量值，看看会出现什么结果。下面的源代码中，Block 语法之前声明的自动变量 val 的值被赋予1。

int val=0
void ("blk)(void) = ^{val = 1;};
blk();
printf("val = %d\n",val);

以上为在 Block 语法外声明的给自动变量赋值的源代码。该源代码会产生编译错误。

error: variable is not assignable (missing __block type specifier)
void (^blk)(void)= ^{val = 1;};

若想在 Block 语法的表达式中将值赋给在 Block 语法外声明的自动变量，需要在该自动变量上附加 block 说明符。该源代码中，如果给自动变量声明 int val附加 block 说明符，就能实现在Block 内赋值。

_block int val = 0;
void (^blk)(void) = ^{val = 1;};
blk();
printf("val = d\n",val);

执行结果：

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(^b1k)(void) = ^(
array =[[NSMutableArray alloc] init];
};

error: variable is not assignable(missingblock type specifier)
array = [[NSMutableArray alloc] init];

这种情况下，需要给截获的自动变量附加_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]);
};

只是使用C语言的字符串字面量数组，而并没有向截获的自动变量赋值，因此看似没有问题。但实际上会产生以下编译错误∶

error; cannot refer to declaration with an array type inside block
printf("cAn",text[2]);note: declared here
const char text [] ="hello";

这是因为在现在的 Blocks 中，截获自动变量的方法并没有实现对C语言数组的截获。这时，使用指针可以解决该问题。

const char *text = "hello";
void (^blk)(void)= ^{
	printf("%c\n",text [2]);
}

Blocks的实现

Block的实质

Block是"带有自动变量值的匿名函数"，但 Block究竟是什么呢?本节将通过Block 的实现进一步帮大家加深理解。

前几节讲的 Block 语法看上去好像很特别，但它实际上是作为极普通的C语言源代码来处理的。通过支持 Block 的编译器，含有Block 语法的源代码转换为一般C语言编译器能够处理的源代码，并作为极为普通的C 语言源代码被编译。
这不过是概念上的问题，在实际编译时无法转换成我们能够理解的源代码，但 clang（LLVM 编译器）具有转换为我们可读源代码的功能。通过"-rewrite-objc"选项就能将含有Block 语法的源代码变换为C++的源代码。说是C++，其实也仅是使用了struct结构，其本质是C语言源代码。

clang -rewrite-objc 源代码文件名

下面，我们转换 Block 语法。

int main() {
	void (^blk)(void) = ^{printf("Block\n");};
	blk();
	return 0;
}

此源代码的 Block 语法最为简单，它省略了返回值类型以及参数列表。该源代码通过 clang 可变换为以下形式∶

//经过clang转换后的C++代码
struct __block_impl {
  void *isa;
  int Flags;
  int Reserved;
  void *FuncPtr;
};

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("Block\n");
}

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[]) {
	void (*blk)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA));
	
	((void (*)(__block_impl *))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk);
    return 0;
}