上一章节里面，我们分析了一下胚胎版的Block的底层结构。现在我们加点料进去

#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        //Block的定义
        void (^block)(int, int) = ^(int a, int b){
            NSLog(@"I am a block! - %d - %d", a, b);
        };
        //Block的调用
        block(10, 20);
    }
    return 0;
}
****************************** 日志输出 *******************************
2019-06-04 15:30:57.747093+0800 Interview03-block[3915:354992] I am a block! - 10 - 20
Program ended with exit code: 0

这里我们给block所封装的函数增加两个参数a、b，还是惯例，通过命令
xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc main.m -o main.cpp
然后打开编译后的c++文件

block中的函数带参数

Block捕获auto变量

接下来看看这种情况

#import <Foundation/Foundation.h>

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        int age = 10;
        //Block的定义
        void (^block)(void) = ^(){
            NSLog(@"Age is %d", age);
        };
        //先修改age的值
        age = 20;
        //Block的调用
        block();
    }
    return 0;
}

我在block之前定义了一个int a = 10，然后在block内部使用了这个age，而且我在调用block之前，先将age的值修改成了20，那么此时程序运行会是什么结果呢？相信以大部分人对block的了解，应该都能给出正确答案。

2019-06-04 15:46:01.244557+0800 Interview03-block[4064:375528] Age is 10
Program ended with exit code: 0

结果是block中打印出的a是10，我们在block外部对age的修改结果并没有对block的内部打印产生影响，为什么呢？我们同样，借助编译后的c++文件来看一看。

(1)首先看一下此时block对应的结构体

我们发现有三处变化

• 新增了一个int age成员变量
• 构造函数里面多了一个参数 int _age
• 构造函数里面参数尾部多了一个: age(_age)，这是c++的语法，作用时将参数_age自动赋值给成员变量age

(2)然后在看一下main函数中的block定义以及赋值的代码

在用block构造函数生成block的时候，使用了外部定义的 int a = 10,因为c函数的参数都是值传递，所以这里是将此时外部变量a的值10传给了block的构造函数__main_block_impl_0，因此block内部的成员变量age会被赋值成10。

(3)再看一下block内部封装的函数

可以看到打印代码里面使用的age，实际上就是block内部的成员变量age，不是我们在外面定义的那个age，因此，当block被赋值之后，其成员变量age被赋值成了当时构造函数传进来的参数10，所以最终打印出来值就是10，不论外部的age再如何的修改。外部的age跟block的成员变量age是两个不同的变量，互不影响。

其实，上面我门讨论的这个block外部变量age是一个局部auto变量，也叫自动变量，这是C语言的知识点，如果有不清楚的请自行补脑。我们知道除了auto变量，C语言里面还有局部static变量（静态变量）和全局变量，接下来我们就看看，Block对于这几种变量的使用，做了如何的处理。

Block捕获局部static变量

首先我们将上面的OC代码改造如下

#import <Foundation/Foundation.h>

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        int age = 10;
        static int height = 10;
        //Block的定义
        void (^block)(void) = ^(){
            NSLog(@"Age is %d, height is %d", age, height);
        };
        //先修改age和height的值
        age = 20;
        height = 20;
        //Block的调用
        block();
    }
    return 0;
}

我们有增加了一个static变量height，并且在同样的地方修改height的值，便于和之前的age进行对比。首先运行代码看一下结果

2019-06-04 17:10:12.935220+0800 Interview03-block[4725:476530] Age is 10, height is 20
Program ended with exit code: 0

可以看到，block输出的 height值是我们在外部重新为其赋的20。
为什么呢，我们进入编译后的C++文件一看究竟

(1)借用上面的分析流程一样，先看一下block对应的结构体

你看，针对static变量height, block内部为其增加了一个int *height;成员变量，构造函数里面对应的参数是int *_height。看到这里，应该就大致能猜出来，我们这里要存储的是一个地址，改地址应该就是外部static变量height的地址值。

(2)那我们来看一下main函数里的block赋值过程

对于static变量，block捕获的是它的地址

很清晰，确实block构造函数里面传入的，就是外部的这个height的地址值。

(3)最后看block内部的函数

那么可以看到，block内部的函数也是通过block所存储的地址值*height访问了外部的static变量height的值。

因此，当我们从外部修改height的值之后，调用block打印出的height的值也相应的改变了，因为block内部是通过 指针 引用了外部的这个static变量height。

❓思考❓对于auto、static变量，为什么block选择用不同方式处理它们呢？

我们知道，一个自动变量（auto）的存储空间位于函数栈空间上，在函数开辟栈空间时被创建，在函数结束时销毁，而block的调用时机有可能发生在函数结束之后的，因此就无法使用自动变量了，所以在block一开始定义赋值的过程里，就将自动变量的值拷贝到他自己的存储空间上。
而对于局部静态变量（static），C语法下static会改变所修饰的局部变量的生命周期，使其在 程序整个运行期间都存在 ，所以block选择持有它的指针，在block被调用时，通过该指针访问这个变量的内容就行。

Block使用全局变量

输出结果如下

2019-06-05 09:19:08.854599+0800 Interview03-block[13997:1263406] Age is 20, height is 20
Program ended with exit code: 0

在通过命令行生成一下编译后的C++文件，同样还是在文件底部去看

block使用全局变量

总结

1. 局部变量会被block捕获

• 自动变量（auto），block通过值拷贝方式捕获，在其内部创建一个同类型变量，并且将自动变量的值拷贝给block的内部变量，block代码块执行的时候，直接访问它的这个内部变量。
• 静态变量（static），block通过地址拷贝方式捕获，在其内部创建一个指向同类型变量的指针， 将静态变量的地址值拷贝给block内部的这个指针，block代码块执行的时候，通过内部存储的指针间接访问静态变量。

2. 全局变量不会被block捕获, block代码块执行的时候，通过全局变量名直接访问。

Block对于self的处理

那么有人会问（特别是面试官）下面的情况呢

至此，有关Block对于基础类型环境变量的处理以及调用过程，就整理完毕了。