Block笔记（3）—— 基础类型的变量捕获

Block系列文章—————————————

Block笔记（1）—— 基本认识
Block笔记（2）—— 底层结构
Block笔记（3）—— 基础类型的变量捕获
Block笔记（4）—— Block的类型
Block笔记（5）—— 对象类型的auto变量捕获
Block笔记（6）— __block的深入分析

————————————————————

上一章节里面，我们分析了一下胚胎版的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++文件很明显，参数a、b也被封装进了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中打印出的age是10，我们在block外部对age的修改结果并没有对block的内部打印产生影响，为什么呢？我们同样，借助编译后的c++文件来看一看。

(1)首先看一下此时block对应的结构体我们发现有三处变化

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

(2)然后在看一下main函数中的block定义以及赋值的代码在用block构造函数生成block的时候，使用了外部定义的 int a = 10,因为c函数的参数都是值传递，所以这里是将此时外部变量a的值10传给了block的构造函数__main_block_impl_0，因此block内部的成员变量age会被赋值成10。

(3)再看一下block内部封装的函数__main_block_func_0可以看到打印代码里面使用的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赋值过程很清晰，确实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使用全局变量

上面我们讨论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没有对全局变量进行捕获行为，只需要在要用的时候，直接通过变量名访问就行了，因为全局变量是跨函数的，所以可以直接通过变量的名字直接访问。
同样，这也帮我我们理解了为什么对于局部的变量，block需要对其采取“捕获”行为，正是因为局部变量定在与函数内部，无法跨函数使用，所以根据局部变量不同的存储属性，要么将其值直接进行拷贝（auto），要么对其地址进行拷贝（static）。

总结

1. 局部变量会被block捕获

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

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

Block对于self的处理

请问上图block里面的self会被该block捕获吗？
编译结果显示block对self进行了捕获。But why？
我们知道，图中的block位于test方法里面，实际上任何的oc方法，转换成底层的c函数，里面都有两个默认的参数，self 和 _cmd，所以作为函数默认参数的self的实际上也是该函数的局部变量，根据我们上面总结的原则，只要是局部变量，block都会对其进行捕获，这就解释通了。

那么有人会问（特别是面试官）下面的情况呢
先看编译结果看得出来，还是进行了捕获，看我在图中标明的黄色框框，就很好理解了，block最终访问CLPerson的成员变量_age的时候，是通过self +_age偏移量，获得_age的地址后从而进行间接访问的，所以在oc代码中，_age 的写法等同与self->_age，说白了，这里还是需要用到self，因此block还是需要对self进行捕获的。

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

Block系列文章—————————————

Block笔记（1）—— 基本认识
Block笔记（2）—— 底层结构
Block笔记（3）—— 基础类型的变量捕获
Block笔记（4）—— Block的类型
Block笔记（5）—— 对象类型的auto变量捕获
Block笔记（6）— __block的深入分析

————————————————————