iOS Blocks 第一弹｜基础知识

Blocks 系列是基于学习《Pro Multithreading and Memory Management for iOS and OS X with ARC, Grand Central Dispatch, and Blocks》 一书过程中的笔记整理而来的。

Block 是在 iOS 开发过程中经常出现的角色。它是由 Apple 在 OS X Snow Leopard / iOS 4 上引入的，属于对标准 C 的拓展。Block 可以视为是「带有局部变量的匿名函数（anonymous functions together with automatic variables）」。

我们首先需要区分两个概念：Block 和 Block 类型的变量。Block 是咱们要讲述的主角，而 Block 类型的变量则是一个值类型为 Block 的变量。类似于 int a = 0 中的 0 和 a 的区别。

如何声明 Block 和 Block 类型的变量

声明一个 Block：

^ return_type (argument list) { ... }

返回值 return_type 可以省略，省略后由编译器推断返回值类型，没有返回值时会使用 void ：

^ (argument list) { ... }

如果 Block 执行时不需要参数，(argument list) 也可以省略：

^ { ... }

// 对应的完整形式
^ void (void) { ... }

声明一个 Block 类型的变量：

return_type (^block_variable_name) (argument list)

当然，为了减少多次声明同一种类型变量的工作量，咱们也可以使用 typedef ：

typedef return_type (^block_variable_name)(argument list);

使用 typedef 之后，就能让函数也能返回 Block 类型的值了：

typedef int (^blk_t)(int);

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

C 语言中通过函数返回一个 Block 类型的值，必须使用 typedef ，而 Objc 则不需要：

- (void (^)(void)) myFunctionReturningABlock {
    return ^ { ... };
}

声明一个 Block，并将其赋值给 Block 类型的变量：

int (^block) (int) = ^ (int param) { return param + 1; };

把 Block 作为函数的参数：

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

// 或者
typedef int (^blk_t)(int);
void func(blk_t block) {
		// ...
}

Block 和函数指针

C 语言中，函数指针的声明以及使用方式为：

#include "stdio.h"

int test(int arg) {
    return arg;
}

int main() {
    int (*funcptr)(int) = &test;
    printf("%d", funcptr(100));
}

// output: 100

对比一下 Block 类型的变量和函数指针类型的变量，两者非常相似，只不过函数指针使用 * 而 Block 使用 ^ 。

int (*funcptr) (int) 

int (^block) (int)

大部分函数只需要关心函数体内的逻辑，而 Block 既需要关心其内部的处理逻辑，还需要关心 Block 外部的上下文。在接下来的学习过程中，我们会发现 Block 的底层实现里面少不了函数指针的身影，函数指针在 Block 里充当着处理 Block 内部计算逻辑的角色。

Block 对变量的捕获

前面提到，Block 可以视为是「带有局部变量的匿名函数」。这是因为 Block 可以捕获局部变量，这也是 Block 和函数指针的最大区别——能够存储上下文信息。

捕获局部变量的值

先看一段代码：

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();

// output
// val = 10

这段代码首先初始化了一个 int 型的变量 val 以及一个字符串 fmt 。然后声明一个 Block 类型的变量 blk，并在这个 Block 中捕获了变量 val 以及 fmt 。

最后修改变量 val 以及 fmt 的值，并执行 blk 后发现输出结果依旧使用了两个变量修改前的值。这说明 Block 对局部变量的捕获就是直接捕获变量的值，不是通过内部的指针指向原来的变量，而是内部有一个新的变量直接存了变量的值，两者没有「纠缠」关系。

对 self 的捕获也是类似，self 在方法作用域里，其实也可以看作一个局部变量或者方法的参数。类似 python 中的实例方法，默认第一个参数就是 self ，只不过 OC 或者 C++ 里面默认把 self 或者 this 给隐藏了，后面的文章里会具体说这个。

class MyClass:
    def method(self, param: int):
				pass

如果 Block 捕获了 self ，也就是其内部有变量被赋值为 self 的值，那么 Block 会强持有 self 。这时候 self 再持有 Block 的话，就会出现循环引用问题。

Block 内修改局部变量的值

Block 捕获变量的值后，一般情况下，编译器是不允许在 Block 内部修改变量的值。因为 Block 内部有一个新的变量（假设为 A）存储了被捕获变量（假设为 B）的值，A 和 B 之间没有连接关系，修改其中一方不会影响另一方的值。编译器会阻止这种试图通过修改 A 的值来影响 B 的行为。

例如下面代码会报错：

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

但是既然说了这是一般情况，那肯定还有特殊情况。

如果想要在 Block 内部修改外界变量的值，需要使用 __block 关键字。给局部变量加上 __block 关键字之后，编译器就允许在 Block 内修改外面变量的值：

__block int val = 0;
void (^blk)(void) = ^{ val = 1; };
// 此时编译器不再报错

下一篇文章会讲到，这时候的 val 在底层已经不是一个 int 类型的变量，而是一个结构体。

Block 无法捕获 C 数组

下面代码尝试在 Block 内捕获一个 C 数组，但编译器会报错。

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

// error: cannot refer to declaration with an array type inside block
//         printf("%c\n", text[2]);
//                       ^
// note: 'text' declared here
//    const char text[] = "hello";
//               ^

这是因为 Block 无法捕获 C 数组，具体原因会在下一篇的文章中讲述。如果想要在 Block 内读取外部的 C 数组，可以让 Block 捕获一个 C 数组的指针：

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