block详解<2>: block如何捕获外部变量？

先看一段代码

int main(int argc, const char * argv[]) {
    @autoreleasepool {
       
        int value = 1;
       void (^block)(void) = ^{
           NSLog(@"value1 = %d",value);
        };
        block();
        
    }
    return 0;
}

执行上面的代码，打印的结果为1.说明block成功获取了外部的变量value的值。通过前面clang编译的代码:我们发现block的执行函数是:__main_block_func_0,value是定义在main函数中的，也就是说__main_block_func_0这个函数获取了main函数中的局部变量的值，我们来看看这到底是如何发生的。依然通过clang命令。

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  int value;
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _value, int flags=0) : value(_value) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  int value = __cself->value; // bound by copy

            NSLog((NSString *)&__NSConstantStringImpl__var_folders_7s_lqjprsgx1p77_5nhhmj9q7wm0000gn_T_main_31d092_mi_0,value);
        }

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[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 

        int value = 1;

        void (*block)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, value));
        ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);

    }
    return 0;
}

我们直接从入口函数main函数开始看，发现value的值通过结构体的构造函数封装进了结构体__main_block_impl_0中，而这个结构体又作为参数传入进了block的执行函数
__main_block_func_0(struct __main_block_impl_0 *__cself)，所以在block的执行函数中可以看到这行代码:int value = __cself->value; 这也就证明了可以在block中捕获外部变量。但是如果我们想修改value的值，会报错

屏幕快照 2016-09-21 3.51.36 PM.png

也就是说，我们只能读取value的值，不能修改value。那我们如何才能修改value的值，这里大家应该都知道，需要加一个修饰符:__block.那么为什么加了一个这样的修饰符之后，就可以修改呢？我们还是通过clang来分析一下。首先修改一下上面的代码

int main(int argc, const char * argv[]) {
    @autoreleasepool {
       
       __block int value = 1;
       void (^block)(void) = ^{
           value ++ ;
           NSLog(@"value1 = %d",value);
        };
        block();
        
    }
    return 0;
}

clang之后得到如下代码

屏幕快照 2016-09-21 4.02.44 PM.png

加了__block修饰符之后，比之前主要多了三个东西:

• __Block_byref_value_0 : 这是一个结构体，是对外部变量value的封装
• __main_block_copy_0 : copy函数，功能是把外部数据拷贝到堆上
• __main_block_dispose_0: 释放函数，把堆上的数据释放掉

下面对部分编译代码进行解释

struct __Block_byref_value_0 {
  void *__isa;
__Block_byref_value_0 *__forwarding; //指向自己的一个指针，后面对外部变量修改的操作都是通过这个指针来操作的
 int __flags;
 int __size;
 int value;
};

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  __Block_byref_value_0 *value; // 用来接收外部变量封装的block
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_value_0 *_value, int flags=0) : value(_value->__forwarding) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  __Block_byref_value_0 *value = __cself->value; // bound by ref

            (value->__forwarding->value)++; //通过指针来修改值，所以是可以成功的
            NSLog((NSString *)&__NSConstantStringImpl__var_folders_7s_lqjprsgx1p77_5nhhmj9q7wm0000gn_T_main_693ef0_mi_0,(value->__forwarding->value));
        }

//可以理解为把外部变量valuecopy到堆上，这样可以避免在超出局部变量的作用域时，继续访问该局部变量，局部变量内存已经被释放
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {_Block_object_assign((void*)&dst->value, (void*)src->value, 8/*BLOCK_FIELD_IS_BYREF*/);}

//可以理解为释放相应的内存
static void __main_block_dispose_0(struct __main_block_impl_0*src) {_Block_object_dispose((void*)src->value, 8/*BLOCK_FIELD_IS_BYREF*/);}

static struct __main_block_desc_0 {
  size_t reserved;
  size_t Block_size;
  void (*copy)(struct __main_block_impl_0*, struct __main_block_impl_0*);
  void (*dispose)(struct __main_block_impl_0*);
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0), __main_block_copy_0, __main_block_dispose_0};
int main(int argc, const char * argv[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 
        // 加了__block之后，之前定义的int型变量，变成了结构体类型 __Block_byref_value_0，而且可以发现第二个参数取的是自身的地址，也就是指向自身
        __attribute__((__blocks__(byref))) __Block_byref_value_0 value = {(void*)0,(__Block_byref_value_0 *)&value, 0, sizeof(__Block_byref_value_0), 1};
        
        //把上面那个结构体的指针(看清楚传的是&value，所以后面可以修改)传进了__main_block_impl_0中，由此，后面的一系列操作，其实都是指针的一些列操作
        void (*block)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_value_0 *)&value, 570425344));
        ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);

    }
    return 0;
}

在变量的前面加上了 _ block之后，就可以修改值了，就是因为做的引用传递(也就是指针传递)，而不加 _block的变量，就相当于值传递，所以在内部修改是不能改变外部变量的值的。

这里指明一点儿， _main_block_copy_0 和 _main_block_dispose_0这两个函数并不是因为加了_block所特有的，只要block里面捕获的变量是指针类型，都会多出这两个函数，比如：

屏幕快照 2016-09-22 1.56.40 PM.png

clang之后，也会有这两个函数：这是因为如果block在超出变量的作用域外调用，变量可能已经被释放，访问一块儿已经被释放的内存，是会出问题的。比如下面下面的情况

屏幕快照 2016-09-22 2.04.24 PM.png

如果没有把str拷贝到堆上的话，出了里面的{},str就会被释放，再去调用blk(),就会访问一块儿已经释放的内存，从而造成错误。