先看一段代碼

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

執(zhí)行上面的代碼，打印的結(jié)果為1.說明block成功獲取了外部的變量value的值。通過前面clang編譯的代碼:我們發(fā)現(xiàn)block的執(zhí)行函數(shù)是:__main_block_func_0,value是定義在main函數(shù)中的，也就是說__main_block_func_0這個函數(shù)獲取了main函數(shù)中的局部變量的值，我們來看看這到底是如何發(fā)生的。依然通過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;
}

我們直接從入口函數(shù)main函數(shù)開始看，發(fā)現(xiàn)value的值通過結(jié)構(gòu)體的構(gòu)造函數(shù)封裝進(jìn)了結(jié)構(gòu)體__main_block_impl_0中，而這個結(jié)構(gòu)體又作為參數(shù)傳入進(jìn)了block的執(zhí)行函數(shù)
__main_block_func_0(struct __main_block_impl_0 *__cself)，所以在block的執(zhí)行函數(shù)中可以看到這行代碼:int value = __cself->value; 這也就證明了可以在block中捕獲外部變量。但是如果我們想修改value的值，會報錯

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

也就是說，我們只能讀取value的值，不能修改value。那我們?nèi)绾尾拍苄薷膙alue的值，這里大家應(yīng)該都知道，需要加一個修飾符:__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 : 這是一個結(jié)構(gòu)體，是對外部變量value的封裝
• __main_block_copy_0 : copy函數(shù)，功能是把外部數(shù)據(jù)拷貝到堆上
• __main_block_dispose_0: 釋放函數(shù)，把堆上的數(shù)據(jù)釋放掉

下面對部分編譯代碼進(jìn)行解釋

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到堆上，這樣可以避免在超出局部變量的作用域時，繼續(xù)訪問該局部變量，局部變量內(nèi)存已經(jīng)被釋放
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*/);}

//可以理解為釋放相應(yīng)的內(nèi)存
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型變量，變成了結(jié)構(gòu)體類型 __Block_byref_value_0，而且可以發(fā)現(xiàn)第二個參數(shù)取的是自身的地址，也就是指向自身
        __attribute__((__blocks__(byref))) __Block_byref_value_0 value = {(void*)0,(__Block_byref_value_0 *)&value, 0, sizeof(__Block_byref_value_0), 1};
        
        //把上面那個結(jié)構(gòu)體的指針(看清楚傳的是&value，所以后面可以修改)傳進(jìn)了__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的變量，就相當(dāng)于值傳遞，所以在內(nèi)部修改是不能改變外部變量的值的。

這里指明一點兒， _main_block_copy_0 和 _main_block_dispose_0這兩個函數(shù)并不是因為加了_block所特有的，只要block里面捕獲的變量是指針類型，都會多出這兩個函數(shù)，比如：

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

clang之后，也會有這兩個函數(shù)：這是因為如果block在超出變量的作用域外調(diào)用，變量可能已經(jīng)被釋放，訪問一塊兒已經(jīng)被釋放的內(nèi)存，是會出問題的。比如下面下面的情況

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

如果沒有把str拷貝到堆上的話，出了里面的{},str就會被釋放，再去調(diào)用blk(),就會訪問一塊兒已經(jīng)釋放的內(nèi)存，從而造成錯誤。