block 捕获变量

image.png

cd ~/.m所在文件夹路径
clang -rewrite-objc main.m

捕获-auto自动变量

auto变量是声明在函数内部的变量，比如int a = 0;这句代码声明在函数内部，那a就是auto变量，等价于auto int a = 0;auto变量时分配在栈区，当超出作用域时，其占用的内存会被系统自动销毁并生成。下面看一段代码：

int a = 10;
void (^block)(void) = ^{
      NSLog(@"%d", a);
};
a = 20;
block();

输出：10

自动变量a的值明明已经变为了20，为什么输出结果还是10呢？我们把这段代码转化为C++的源码看看。

int main(int argc, char * argv[]) {
/* @autoreleasepool / { __AtAutoreleasePool __autoreleasepool;
int a = 10;
void (block)(void) = ((void (*)())&__main_block_impl_0((void )__main_block_func_0, &__main_block_desc_0_DATA, a));
a = 20;
((void ()(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
return 0;
}
}

对比一下上面分析的没有捕获自动变量的源代码，我们发现这里_main_block_impl_0中传入的参数多了一个a。然后我们往上翻看看_main_block_impl_0的结构：

struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
int a; //这里也多了一个a
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _a, int flags=0) : a(_a) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};

在_main_block_impl_0这个结构体中我们发现多了一个int类型的成员变量a，在结构体的构造函数中多了一个参数int _a，并且用这个int _a去初始化成员变量a。所以在void (*block)(void) = &__main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA, a);中传入了自动变量a用来初始化_main_block_impl_0的成员变量a。那这个时候_main_block_impl_0的成员变量a就被赋值为10了。由于上面这一步是值传递，所以当执行a = 20时，_main_block_impl_0结构体的成员变量a的值是不会随之改变的，仍然是10。然后我们再来看一下_main_block_func_0的结构有何变化：

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
int a = __cself->a; // bound by copy
NSLog((NSString *)&__NSConstantStringImpl__var_folders_74_wk04zv690mz36wn0g18r5nxm0000gn_T_main_fb5f0d_mi_0, a);
}

可以看到，通过传入的_main_block_impl_0这个结构体获得其成员变量a的值。

捕获-static变量

上面讲的捕获的是自动变量，在函数内部声明的变量默认为自动变量，即默认用auto修饰。那么如果在函数内部声明的变量用static修饰，又会带来哪些不同呢？static变量和auto变量的不同之处在于变量的内存的回收时机。auto变量在其作用域结束时就会被系统自动回收，而static变量在变量的作用域结束时并不会被系统自动回收。
先看一段代码：

 static int a = 10;
 void (^block)(void) = ^{
    NSLog(@"%d", a);
 };
 a = 20;
 block();

输出：20

结果是20，这个和2中的打印结果不一样，为什么局部变量从auto变成了static结果会不一样呢？我们还是从源码来分析：

int main(int argc, char * argv[]) {
/* @autoreleasepool / { __AtAutoreleasePool __autoreleasepool;
static int a = 10;
void (block)(void) = ((void (*)())&__main_block_impl_0((void )__main_block_func_0, &__main_block_desc_0_DATA, &a));
a = 20;
((void ()(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
return 0;
}
}

和2不一样的是，这里传入_main_block_impl_0的是&a，

image

也即是a这个变量的地址值。那么这个&a是赋值给谁了呢？我们上翻找到_main_block_impl_0的结构：

struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
int *a;
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int *_a, int flags=0) : a(_a) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};

这里我们可以看到结构体多了一个指针类型的成员变量int *a,然后在构造函数中，将传递过来的&a，赋值给这个指针变量。也就是说，在_main_block_impl_0这个结构体中多了一个成员变量，这个成员变量是指针，指向a这个变量。所以当a变量的值发生变化时，能够得到最新的值。

捕获-全局变量

2和3分析了两种类型的局部变量，auto局部变量和static局部变量。这一部分则分析全局变量。全局变量会不会像局部变量一样被block所捕获呢？我们还是看一下实例：

int height = 10;
static int weight = 20;
int main(int argc, char * argv[]) {
    @autoreleasepool {
        void (^block)(void) = ^{
            NSLog(@"%d %d", height, weight);
        };
        height = 30;
        weight = 40;
        block();
        return 0;
    }
}

打印：30 40

查看源码

int height = 10;
static int weight = 20;
int main(int argc, char * argv[]) {
/* @autoreleasepool / { __AtAutoreleasePool __autoreleasepool;
void (block)(void) = ((void (*)())&__main_block_impl_0((void )__main_block_func_0, &__main_block_desc_0_DATA));
height = 30;
weight = 40;
((void ()(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
return 0;
}
}

这里我们可以看到，height和weight这两个全局变量没有作为参数传入_main_block_impl_0中去。然后我们再查看一下_main_block_impl_0的结构：

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;
}
};

可以看到，_main_block_impl_0中并没有增加成员变量。然后我们再看_main_block_func_0的结构：

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
NSLog((NSString *)&__NSConstantStringImpl__var_folders_74_wk04zv690mz36wn0g18r5nxm0000gn_T_main_46c51b_mi_0, height, weight);
}

可以看到，这个地方在调用的时候是直接调用的全局变量height和weight, 所以block并不会捕获全局变量

为什么对于不同类型的变量，block的处理方式不同呢？

这是由变量的生命周期决定的。对于auto变量，当作用域结束时，会被系统自动回收，而block很可能是在超出auto变量作用域的时候去执行，如果之前没有捕获auto变量，那么后面执行的时候，auto变量已经被回收了，得不到正确的值。对于static局部变量，它的生命周期不会因为作用域结束而结束，所以block只需要捕获这个变量的地址，在执行的时候通过这个地址去获取变量的值，这样可以获得变量的最新的值。而对于全局变量，在任何位置都可以直接读取变量的值。

为什么对于auto变量block捕获的是数值而 对于static局部变量捕获的是地址？

还是由变量的生命周期决定的，对于auto变量，当作用域结束时，会被系统自动回收，地址就会变成空的，造成坏地址访问。对于static局部变量，它的生命周期不会因为作用域结束而结束，所以block只需要捕获这个变量的地址，在执行的时候通过这个地址去获取变量的值。

转载自 木子雨廷t