美文网首页
Block之变量捕获

Block之变量捕获

作者: LaoQianYJ | 来源:发表于2020-04-18 15:49 被阅读0次

1. 不同类型变量捕获

主要有全局变量、全局静态变量、局部变量、局部静态变量,代码如下:

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

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        
        // 局部变量
        int count = 10;
        // 静态局部变量
        static int static_count = 10;
        
        void (^block)(void);
        
        // 访问全局变量,并修改
        block = ^{
          
            NSLog(@"global_count:%d 地址:%p", global_count, &global_count);
            global_count = 11;
            NSLog(@"global_count:%d 地址:%p", global_count, &global_count);
        };
        
        block();
        NSLog(@"global_count:%d 地址:%p", global_count, &global_count);
        global_count = 12;
        NSLog(@"global_count:%d 地址:%p", global_count, &global_count);
        
        // 访问全局静态变量,并修改
        block = ^{
          
            NSLog(@"static_globbal_count:%d 地址:%p", static_globbal_count, &static_globbal_count);
            static_globbal_count = 11;
            NSLog(@"static_globbal_count:%d 地址:%p", static_globbal_count, &static_globbal_count);
        };
        
        block();
        NSLog(@"static_globbal_count:%d 地址:%p", static_globbal_count, &static_globbal_count);
        static_globbal_count = 12;
        NSLog(@"static_globbal_count:%d 地址:%p", static_globbal_count, &static_globbal_count);
        
        
        // 访问局部变量,并修改
        NSLog(@"count:%d 地址:%p", count, &count);
        block = ^{
          
            NSLog(@"count:%d 地址:%p", count, &count);
//            count = 11;
//            NSLog(@"count:%d 地址:%p", count, &count);
        };
        
        block();
        NSLog(@"count:%d 地址:%p", count, &count);
        count = 12;
        NSLog(@"count:%d 地址:%p", count, &count);
        
        
        // 访问静态局部变量,并修改
        block = ^{
                  
            NSLog(@"static_count:%d 地址:%p", static_count, &static_count);
            static_count = 11;
            NSLog(@"static_count:%d 地址:%p", static_count, &static_count);
        };
        
        block();
        NSLog(@"static_count:%d 地址:%p", static_count, &static_count);
        static_count = 12;
        NSLog(@"static_count:%d 地址:%p", static_count, &static_count);
        
         
        
        
    }
    return 0;
}

执行以上代码,获取打印数据:

global_count:10 地址:0x100002030
global_count:11 地址:0x100002030
global_count:11 地址:0x100002030
global_count:12 地址:0x100002030

static_globbal_count:10 地址:0x100002038
static_globbal_count:11 地址:0x100002038
static_globbal_count:11 地址:0x100002038
static_globbal_count:12 地址:0x100002038

count:10 地址:0x7ffeefbff57c
count:10 地址:0x100703e50
count:10 地址:0x7ffeefbff57c
count:12 地址:0x7ffeefbff57c

static_count:10 地址:0x100002034
static_count:11 地址:0x100002034
static_count:11 地址:0x100002034
static_count:12 地址:0x100002034

从打印输出,我们可以得出一个结论:

  • 除了局部变量,其它的类型我们都可以在block中直接访问并修改,且存储空间不变,这说明指针引用
  • 而局部变量我们可以在block中获取,但是并不能修改(编译器会直接报错),并且在block访问局部变量后,其内存地址发生了改变,这代表着在访问外部变量的时候并不是指针引用,而是值引用

2. 底层分析

通过clang -rewrite-objc main.m生成main.cpp文件,从中获取到:

int global_count = 10;

static int static_globbal_count = 10;


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;
  }
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {

            NSLog((NSString *)&__NSConstantStringImpl__var_folders_7x_02rxw4ms63z1hyly7yn3nj040000gn_T_main_bd7e26_mi_0, global_count, &global_count);
            global_count = 11;
            NSLog((NSString *)&__NSConstantStringImpl__var_folders_7x_02rxw4ms63z1hyly7yn3nj040000gn_T_main_bd7e26_mi_1, global_count, &global_count);

        }

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

struct __main_block_impl_1 {
  struct __block_impl impl;
  struct __main_block_desc_1* Desc;
  __main_block_impl_1(void *fp, struct __main_block_desc_1 *desc, int flags=0) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
static void __main_block_func_1(struct __main_block_impl_1 *__cself) {

            NSLog((NSString *)&__NSConstantStringImpl__var_folders_7x_02rxw4ms63z1hyly7yn3nj040000gn_T_main_bd7e26_mi_4, static_globbal_count, &static_globbal_count);
            static_globbal_count = 11;
            NSLog((NSString *)&__NSConstantStringImpl__var_folders_7x_02rxw4ms63z1hyly7yn3nj040000gn_T_main_bd7e26_mi_5, static_globbal_count, &static_globbal_count);

        }

static struct __main_block_desc_1 {
  size_t reserved;
  size_t Block_size;
} __main_block_desc_1_DATA = { 0, sizeof(struct __main_block_impl_1)};

struct __main_block_impl_2 {
  struct __block_impl impl;
  struct __main_block_desc_2* Desc;
  int count;
  __main_block_impl_2(void *fp, struct __main_block_desc_2 *desc, int _count, int flags=0) : count(_count) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
static void __main_block_func_2(struct __main_block_impl_2 *__cself) {
  int count = __cself->count; // bound by copy


            NSLog((NSString *)&__NSConstantStringImpl__var_folders_7x_02rxw4ms63z1hyly7yn3nj040000gn_T_main_bd7e26_mi_8, count, &count);

            NSLog((NSString *)&__NSConstantStringImpl__var_folders_7x_02rxw4ms63z1hyly7yn3nj040000gn_T_main_bd7e26_mi_9, count, &count);

        }

static struct __main_block_desc_2 {
  size_t reserved;
  size_t Block_size;
} __main_block_desc_2_DATA = { 0, sizeof(struct __main_block_impl_2)};

struct __main_block_impl_3 {
  struct __block_impl impl;
  struct __main_block_desc_3* Desc;
  int *static_count;
  __main_block_impl_3(void *fp, struct __main_block_desc_3 *desc, int *_static_count, int flags=0) : static_count(_static_count) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
static void __main_block_func_3(struct __main_block_impl_3 *__cself) {
  int *static_count = __cself->static_count; // bound by copy


            NSLog((NSString *)&__NSConstantStringImpl__var_folders_7x_02rxw4ms63z1hyly7yn3nj040000gn_T_main_bd7e26_mi_12, (*static_count), &(*static_count));
            (*static_count) = 11;
            NSLog((NSString *)&__NSConstantStringImpl__var_folders_7x_02rxw4ms63z1hyly7yn3nj040000gn_T_main_bd7e26_mi_13, (*static_count), &(*static_count));
        }

static struct __main_block_desc_3 {
  size_t reserved;
  size_t Block_size;
} __main_block_desc_3_DATA = { 0, sizeof(struct __main_block_impl_3)};
int main(int argc, const char * argv[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 
        int count = 10;

        static int static_count = 10;

        void (*block)(void);

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

        ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
        NSLog((NSString *)&__NSConstantStringImpl__var_folders_7x_02rxw4ms63z1hyly7yn3nj040000gn_T_main_bd7e26_mi_2, global_count, &global_count);
        global_count = 12;
        NSLog((NSString *)&__NSConstantStringImpl__var_folders_7x_02rxw4ms63z1hyly7yn3nj040000gn_T_main_bd7e26_mi_3, global_count, &global_count);


        block = ((void (*)())&__main_block_impl_1((void *)__main_block_func_1, &__main_block_desc_1_DATA));

        ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
        NSLog((NSString *)&__NSConstantStringImpl__var_folders_7x_02rxw4ms63z1hyly7yn3nj040000gn_T_main_bd7e26_mi_6, static_globbal_count, &static_globbal_count);
        static_globbal_count = 12;
        NSLog((NSString *)&__NSConstantStringImpl__var_folders_7x_02rxw4ms63z1hyly7yn3nj040000gn_T_main_bd7e26_mi_7, static_globbal_count, &static_globbal_count);


        block = ((void (*)())&__main_block_impl_2((void *)__main_block_func_2, &__main_block_desc_2_DATA, count));

        ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
        NSLog((NSString *)&__NSConstantStringImpl__var_folders_7x_02rxw4ms63z1hyly7yn3nj040000gn_T_main_bd7e26_mi_10, count, &count);
        count = 12;
        NSLog((NSString *)&__NSConstantStringImpl__var_folders_7x_02rxw4ms63z1hyly7yn3nj040000gn_T_main_bd7e26_mi_11, count, &count);


        block = ((void (*)())&__main_block_impl_3((void *)__main_block_func_3, &__main_block_desc_3_DATA, &static_count));

        ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
        NSLog((NSString *)&__NSConstantStringImpl__var_folders_7x_02rxw4ms63z1hyly7yn3nj040000gn_T_main_bd7e26_mi_14, static_count, &static_count);
        static_count = 12;
        NSLog((NSString *)&__NSConstantStringImpl__var_folders_7x_02rxw4ms63z1hyly7yn3nj040000gn_T_main_bd7e26_mi_15, static_count, &static_count);
    }
    return 0;
}

通过分析:

  • 在捕获全局变量的时候,__main_block_impl_0和__main_block_impl_1中没有新增成员变量,因为全局变量的作用域是全局的,所以block内部修改会直接改变他们的值
  • 而捕获局部变量的时候:
  • 1.如果是局部变量,会在__main_block_impl_2结构体重生成了一个int count的成员变量,这表示在声明block的时候就将count值保存到了结构体内部,这是一个值传递,同时说明了再调用前修改外部变量的值并不会影响到block内部的count值
  • 2.如果是局部静态变量,在__main_block_impl_3中生成了一个int *static_count的指针,在声明block的时候就会将外部变量的指针保存到结构体中,因为是指针引用,所以在block内部队static_count的修改会直接影响到static_count的值

3. __block修饰符

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // 局部变量
        __block int count = 10;
        void (^block)(void);
        
        // 访问局部变量,并修改
        block = ^{
            NSLog(@"count:%d 地址:%p", count, &count);
            count = 11;
            NSLog(@"count:%d 地址:%p", count, &count);
        };
        
        block();
        NSLog(@"count:%d 地址:%p", count, &count);
        count = 12;
        NSLog(@"count:%d 地址:%p", count, &count);
    }
}

通过clang生成main.cpp文件:

struct __Block_byref_count_0 {
  void *__isa;
__Block_byref_count_0 *__forwarding;
 int __flags;
 int __size;
 int count;
};

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;
  }
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  __Block_byref_count_0 *count = __cself->count; // bound by ref


            NSLog((NSString *)&__NSConstantStringImpl__var_folders_7x_02rxw4ms63z1hyly7yn3nj040000gn_T_main_05e572_mi_0, (count->__forwarding->count), &(count->__forwarding->count));
            (count->__forwarding->count) = 11;
            NSLog((NSString *)&__NSConstantStringImpl__var_folders_7x_02rxw4ms63z1hyly7yn3nj040000gn_T_main_05e572_mi_1, (count->__forwarding->count), &(count->__forwarding->count));



        }
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*/);}

static void __main_block_dispose_0(struct __main_block_impl_0*src) {_Block_object_dispose((void*)src->count, 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; 
        __attribute__((__blocks__(byref))) __Block_byref_count_0 count = {(void*)0,(__Block_byref_count_0 *)&count, 0, sizeof(__Block_byref_count_0), 10};

        void (*block)(void);


        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);
        NSLog((NSString *)&__NSConstantStringImpl__var_folders_7x_02rxw4ms63z1hyly7yn3nj040000gn_T_main_05e572_mi_2, (count.__forwarding->count), &(count.__forwarding->count));
        (count.__forwarding->count) = 12;
        NSLog((NSString *)&__NSConstantStringImpl__var_folders_7x_02rxw4ms63z1hyly7yn3nj040000gn_T_main_05e572_mi_3, (count.__forwarding->count), &(count.__forwarding->count));
    }
    return 0;
}

通过分析我们发现:
在__main_block_impl_0结构体中多了一个__main_block_impl_0结构体
在__main_block_desc_0结构体中多了2个成员变量copy和dispose
多了一个__main_block_copy_0函数
多了一个__main_block_dispose_0函数
多了一个结构体__Block_byref_count_0(捕获变量的封装)

__Block_byref_count_0是_block变量的封装,相当于一个OC对象,我们在main函数中去看看
__attribute__((__blocks__(byref))) __Block_byref_count_0 count = {(void*)0,(__Block_byref_count_0 *)&count, 0, sizeof(__Block_byref_count_0), 10};

// 在声明block的时候将就会生成一个__Block_byref_count_0结构体,在其中将外部变量的地址赋值个__forwarding指针,最后的10就是外部变量的值

// 而在block中修改值的时候:
(count.__forwarding->count) = 12;
// 实际的修改是通过指针来修改的,指针的访问指引是:
__main_block_impl_0 *impl -> __Block_byref_count_0 *count -> __Block_byref_count_0 *__forwarding
// 所以block内部值的修改,外部变量会直接发生改变

4. 总结

通过分析,得出结论:

  • 变量为全局变量和静态变量时,block不会做额外的处理,捕获的是变量的指针,会直接拿来用
  • 变量为局部变量时,只能捕获声明在block前的变量的值,在block中无法修改
  • 被__block修饰的变量,在声明block的时候回被封装成一个结构体(OC对象),改结构体的最后一个成员变量为被__block修饰过的局部变量,block捕获改结构体的指针,在block内部可以修改变量的值

相关文章

  • block:block捕获变量

    一、block捕获变量根儿上的东西 1、block会捕获局部变量 2、block不会捕获全局变量二、block捕获...

  • Block变量捕获详解(一)

    什么是Block变量捕获block变量捕获就是在block内部创建一个变量来存放外部变量什么是值捕获block将外...

  • Block 第三次学习 感谢 MJ老师

    block 内部结构 Block block 变量捕获 变量类型捕获到block 内部访问方式局部变量auto(平...

  • OC基础-Block(2)

    OC基础-Block(2)Block的变量捕获为了保证block内部能够正常访问外部的变量,block有个变量捕获...

  • OC中的Block(二)

    block的变量捕获(capture) 为了保证block内部能够正常访问外部的变量,block有个变量捕获机制 ...

  • block变量的捕获(capture)

    ?为了保证block内部能够正常访问外部变量,block有个变量捕获机制 auto变量的捕获

  • Objective - C block(二)block的类型及捕

    (一)block 捕获变量类型 为了保证block内部能够正确访问外部的变量,block有一个变量捕获机制 (1)...

  • Objective-C Block深入源码

    1. Block捕获自动变量 如何捕获自动变量? Block转换为C函数之后,Block中使用的自动变量会被作为成...

  • 06.4-OC中block捕获对象类型的变量

    block捕获对象类型的变量 前面讲解的block变量捕获,我们讲解了block捕获基本数据类型的情况,下面我们再...

  • iOS开发-7.Block

    1.block的本质 2.block的变量捕获(capture) 3.auto变量的捕获image 4.block...

网友评论

      本文标题:Block之变量捕获

      本文链接:https://www.haomeiwen.com/subject/pkybvhtx.html