[iOS]Block系列探究二 - 捕获变量

上一篇文章中咱们得知了OC的block其实就是C的函数指针，这一篇文章咱们来研究下block与局部变量的各类化学反应。函数

1、截获变量

咱们主要截获三种变量，分别是全局变量、静态全局变量、布局变量、静态局部变量，代码以下：布局

/** 全局变量 */
int global_count = 10;
/** 静态全局变量 */
static int static_global_count = 10;

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // 声明block
        void (^block)(void);
        // 局部变量
        int count = 10;
        // 静态局部变量
        static int static_count = 10;
        // block的实现
        block = ^{
            global_count = 11;
            static_global_count = 11;
            NSLog(@"count = %@", @(count));
            static_count = 11;
        };
        // block的调用
        block();
        // 从新赋值
        global_count = 12;
        static_global_count = 12;
        count = 12;
        static_count = 12;
    }
    return 0;
}
复制代码

上面代码，咱们向block传了一个参数count，如今咱们clang一下，获得下面的C/C++代码：ui

// __block_imp结构体
struct __block_impl {
  void *isa;
  int Flags;
  int Reserved;
  void *FuncPtr;
};

int global_count = 10;

static int static_global_count = 10;

// __main_block_impl_0结构体
struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  int count;
  int *static_count;
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _count, int *_static_count, int flags=0) : count(_count), static_count(_static_count) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

// __main_block_func_0函数
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  int count = __cself->count; // bound by copy
  int *static_count = __cself->static_count; // bound by copy

            global_count = 11;
            static_global_count = 11;
            NSLog((NSString *)&__NSConstantStringImpl__var_folders_0r_hkkmpct143n4wd3xxk0l1j8c0000gn_T_main_23de66_mi_0, ((NSNumber *(*)(Class, SEL, int))(void *)objc_msgSend)(objc_getClass("NSNumber"), sel_registerName("numberWithInt:"), (int)(count)));
            (*static_count) = 11;
        }

// __main_block_desc_0结构体
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)};

// main函数
int main(int argc, const char * argv[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 

        void (*block)(void);

        int count = 10;

        static int static_count = 10;

        block = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, count, &static_count));

        ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);

        global_count = 12;
        static_global_count = 12;
        count = 12;
        static_count = 12;
    }
    return 0;
}
复制代码

咱们重点看一下__main_block_impl_0这个结构体：spa

// __main_block_impl_0结构体
struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  int count;
  int *static_count;
  
  /** 这里须要说明的是：冒号语法后面的内容至关于为参数成员count初始化 int count = _count; */
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _count, int *_static_count, int flags=0) : count(_count), static_count(_static_count) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
复制代码

咱们能够看到__main_block_impl_0结构体多了两个成员变量count和static_count。 在声明block时，count的值就已经被保存到了__main_block_impl_0结构体内部，注意这里是值传递，也就是说在调用前对count从新赋值，并不会影响到__main_block_impl_0结构体内部的count成员变量的值。 一样的，在声明block是，静态变量static_count的指针被保存到了__main_block_impl_0结构体内部，由于是引用传递，因此block内部对static_count的修改会直接影响到static_count的值。 全局变量global_count和静态全局变量static_global_count由于做用域是全局的，因此block内部的修改会直接影响到它们的值。3d

2、__block说明符

咱们都知道block是没法修改外部的局部变量的值的，可是__block却可让咱们修改外部的局部变量的值，接下来咱们探索一下缘由。 首先，上OC代码：指针

// 声明block
void (^block)(void);
__block int count = 10;
// block的实现
block = ^{
    count = 11;
};
// block的调用
block();
// 给count从新赋值
count = 12;
复制代码

咱们clang一下，获得下面代码：code

// __block_impl结构体
struct __block_impl {
  void *isa;
  int Flags;
  int Reserved;
  void *FuncPtr;
};

// __Block_byref_count_0结构体
struct __Block_byref_count_0 {
  void *__isa;
__Block_byref_count_0 *__forwarding;
 int __flags;
 int __size;
 int count;
};

// __main_block_impl_0结构体
struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  __Block_byref_count_0 *count; // by ref
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_count_0 *_count, int flags=0) : count(_count->__forwarding) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

// __main_block_func_0函数
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
    __Block_byref_count_0 *count = __cself->count; // bound by ref
    (count->__forwarding->count) = 11;
}

// __main_block_copy_0函数
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {_Block_object_assign((void*)&dst->count, (void*)src->count, 8/*BLOCK_FIELD_IS_BYREF*/);}

// __main_block_dispose_0函数
static void __main_block_dispose_0(struct __main_block_impl_0*src) {_Block_object_dispose((void*)src->count, 8/*BLOCK_FIELD_IS_BYREF*/);}

// __main_block_desc_0结构体
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; 

        void (*block)(void);
        __attribute__((__blocks__(byref))) __Block_byref_count_0 count = {(void*)0,(__Block_byref_count_0 *)&count, 0, sizeof(__Block_byref_count_0), 10};

        block = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_count_0 *)&count, 570425344));

        ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
        
        (count.__forwarding->count) = 12;
    }
    return 0;
}
复制代码

咱们发现，__main_block_desc_0结构体多了成员变量copy和dispose，另外还多了几个函数和结构体，分别是__Block_byref_count_0结构体、__main_block_copy_0函数和__main_block_dispose_0函数。对象

2.一、__Block_byref_count_0结构体

咱们首先看一下__Block_byref_count_0这个结构体，代码以下：作用域

// __Block_byref_count_0结构体
struct __Block_byref_count_0 {
  void *__isa;
__Block_byref_count_0 *__forwarding;
 int __flags;
 int __size;
 int count 
};
复制代码

这个结构体是__block变量的包装，至关于OC的对象，咱们看一下main()函数中该结构体的初始化函数：get

__attribute__((__blocks__(byref))) __Block_byref_count_0 count = {(void*)0,(__Block_byref_count_0 *)&count, 0, sizeof(__Block_byref_count_0), 10};
复制代码

咱们能够看到结构体中最后的成员变量至关于原局部变量，从成员变量名和初始化函数也能够看出。 咱们来具体看一下__block变量的赋值：

// block的实现
block = ^{
    count = 11;
};
复制代码

这段代码的转换以下：

// __main_block_func_0函数
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
    __Block_byref_count_0 *count = __cself->count; // bound by ref
    (count->__forwarding->count) = 11;
}
复制代码

__main_block_impl_0结构体实例持有指向__block变量的__Block_byref_count_0结构体实例的指针。 __Block_byref_count_0结构体实例的成员变量__forwarding持有指向该实例自身的指针。经过成员变量__forwarding访问成员变量count。成员变量count是该实例自身持有的变量，它至关于局部变量。

3、总结

咱们总结一下，block捕获变量分如下几种状况：

• 变量为全局变量和静态全局变量时，block没有额外处理，直接拿来用；
• 变量为局部变量时，只能捕获在声明block前的变量的值，在block内部不能修改该变量的值。
• 变量为静态局部变量时，捕获该变量的指针，在block内部能够修改该变量的值。
• 变量为被__block修饰过的局部变量是，该变量被包装成结构体（OC对象），该结构体的最后一个成员变量为被__block修饰过的局部变量，block捕获该结构体的指针，在block内部能够修改该变量的值。