欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  移动技术

block本质探寻六之修改变量

程序员文章站 2022-07-05 15:41:13
说明: <1>阅读本文章,请参照前面的block文章加以理解; <2>本文的变量指的是auto类型的局部变量(包括实例对象); <3>ARC和MRC两种模式均适用; 一、无法修改的原因 //代码 很明显,强行给age赋值会报错; //打印 分析:为什么在block内部不能改变age的值?往下看 // ......

说明:

<1>阅读本文章,请参照前面的block文章加以理解;

<2>本文的变量指的是auto类型的局部变量(包括实例对象);

<3>arc和mrc两种模式均适用;

一、无法修改的原因

//代码

 block本质探寻六之修改变量

很明显,强行给age赋值会报错;

void test1()
{
    int age = 10;
    block = ^{
//        age = 20;
        nslog(@"%d", age);
    };
}

//打印

2019-01-15 15:00:43.641417+0800 mj_test[3676:199449] 10
program ended with exit code: 0

分析:为什么在block内部不能改变age的值?往下看

//clang

struct __test1_block_impl_0 {
  struct __block_impl impl;
  struct __test1_block_desc_0* desc;
  int age;
  __test1_block_impl_0(void *fp, struct __test1_block_desc_0 *desc, int _age, int flags=0) : age(_age) {
    impl.isa = &_nsconcretestackblock;
    impl.flags = flags;
    impl.funcptr = fp;
    desc = desc;
  }
};


static void __test1_block_func_0(struct __test1_block_impl_0 *__cself) {
  int age = __cself->age; // bound by copy


        nslog((nsstring *)&__nsconstantstringimpl__var_folders_tb_zgsq5gq15rd3zvbdmw1c09y80000gn_t_main_d8e7e4_mi_0, age);
    }


void test1()
{
    int age = 10;
    block = ((void (*)())&__test1_block_impl_0((void *)__test1_block_func_0, &__test1_block_desc_0_data, age));
}

分析:

<1>age被捕捉到block结构体中,根据输出的结果很明显是在arc模式下,因此当被强指针变量block持有时,系统会自动将block对象从栈区拷贝到堆区;而mrc模式下,因为block对象会随着test1()方法结束,其内存地址会被回收,age的值为乱码

2019-01-15 16:12:43.234301+0800 mj_test[4434:243013] -272632456
program ended with exit code: 0

<2>block代码块是通过__test1_block_func_0函数来实现,而该函数应用的age就是block对象结构体__test1_block_impl_0中的age,这跟test1()方法中的age是两个不同的age:前者存在于堆区,后者存在于栈区;

<3>想要在__test1_block_impl_0函数中去改变test1()方法中的局部变量,显然是不成立的,根本就拿不到该局部变量;

 结论:block对象本身的代码块是存放在一个新的函数中,而block引用的外部auto类型的局部变量存在于block指针变量所在的函数中——所以,两个不同的函数间彼此不可能改变对方内部的局部变量;

 

二、修改方法

1)static修饰

//代码

void test2()
{
    static int age = 10;
    block = ^{
        age = 20;
        nslog(@"%d", age);
    };
}

//打印

2019-01-15 16:31:56.533685+0800 mj_test[4676:255859] 20
program ended with exit code: 0

//clang

struct __test2_block_impl_0 {
  struct __block_impl impl;
  struct __test2_block_desc_0* desc;
  int *age;
  __test2_block_impl_0(void *fp, struct __test2_block_desc_0 *desc, int *_age, int flags=0) : age(_age) {
    impl.isa = &_nsconcretestackblock;
    impl.flags = flags;
    impl.funcptr = fp;
    desc = desc;
  }
};



static void __test2_block_func_0(struct __test2_block_impl_0 *__cself) {
  int *age = __cself->age; // bound by copy

        (*age) = 20;
        nslog((nsstring *)&__nsconstantstringimpl__var_folders_tb_zgsq5gq15rd3zvbdmw1c09y80000gn_t_main_bf7285_mi_1, (*age));
    }

分析:

<1>根据前述文章,此时test2()方法中的整型age是以指针的形式被捕捉到block对象结构体中,该指针变量指向值为10的内存区域;

<2>通过指针当然可以变量该指针指向的内存区域的值(见“__test2_block_func_0”函数),这点没问题——c语言语法基础;

结论:通过static修饰auto类型的局部变量来改变值,其本质是通过指针来改变变量的值;

补充:static修饰的弊端

<1>修改了变量的属性类型——age由整型变量变成整型指针变量;

<2>static修饰的局部变量,是存放在数据区(全局区),直到整个程序结束才会释放内存——不利于内存的有效利用;

 

2)设置为全局变量

此处就不论证,很容易理解,block对象代码块是放在另一个函数中,而该函数是可以访问该全局变量的——这点没问题;

 

3)__block修饰

//代码

void test3()
{
    __block int age = 10;
    block = ^{
        age = 20;
        nslog(@"%d", age);
    };
}

//打印

2019-01-15 16:51:56.337321+0800 mj_test[4909:268533] 20
program ended with exit code: 0

//clang

struct __block_byref_age_0 {
  void *__isa;
__block_byref_age_0 *__forwarding;
 int __flags;
 int __size;
 int age;
};


struct __test3_block_impl_0 {
  struct __block_impl impl;
  struct __test3_block_desc_0* desc;
  __block_byref_age_0 *age; // by ref
  __test3_block_impl_0(void *fp, struct __test3_block_desc_0 *desc, __block_byref_age_0 *_age, int flags=0) : age(_age->__forwarding) {
    impl.isa = &_nsconcretestackblock;
    impl.flags = flags;
    impl.funcptr = fp;
    desc = desc;
  }
};


static void __test3_block_func_0(struct __test3_block_impl_0 *__cself) {
  __block_byref_age_0 *age = __cself->age; // bound by ref

        (age->__forwarding->age) = 20;
        nslog((nsstring *)&__nsconstantstringimpl__var_folders_tb_zgsq5gq15rd3zvbdmw1c09y80000gn_t_main_3fa1c2_mi_2, (age->__forwarding->age));
    }


void test3()
{
    __attribute__((__blocks__(byref))) __block_byref_age_0 age = {(void*)0,(__block_byref_age_0 *)&age, 0, sizeof(__block_byref_age_0), 10};
    block = ((void (*)())&__test3_block_impl_0((void *)__test3_block_func_0, &__test3_block_desc_0_data, (__block_byref_age_0 *)&age, 570425344));
}

分析:

<1>在test3()方法中,被__block修饰的age变量被转成__block_byref_age_0类型的变量,而__block_byref_age_0是一个结构体并且第一个成员变量是isa指针,那么可以肯定__block_byref_age_0类型age是一个oc对象——即经__block修饰的auto类型的局部变量会被系统生成一个新的oc对象;

<2>__block_byref_age_0结构体中:__forwarding是一个指向该结构体本身的指针变量;age就是被捕获到block结构体中的test3()方法中的age(arc会被copy到堆区);

<3>在block对象的代码块函数__test3_block_func_0中,对整型变量age赋值流程:拿到block对象本身结构体中的成员变量age(__block_byref_age_0类型指针变量)——>拿到新生成的oc对象结构体__block_byref_age_0中的成员变量__forwarding——>拿到__block_byref_age_0中的成员变量age;

补充:age->__forwarding->age <=> age->age,但是为什么通过__forwarding(要多一道手续)来拿到最终的整型变量age呢?——该问题后面文章会写到!

 

结论:通过__block修饰auto类型的局部变量来改变值,本质是系统会创建一个临时的oc对象,该对象结构体存储外部变量,而block对象结构体是通过该临时对象来访问外部变量;

补充:

<1> arc模式强指针持有情况下,该oc临时对象很显然是存放在栈区——否则,test3()方法结束后block回调时,不能正确对age变量赋值(会崩溃)——此处涉及block的内存管理问题,后面文章会写到!

<2>该方法并不会改变局部变量的类型,age其依然是atuo int类型;

<3>__block不能修饰static变量和全局变量

block本质探寻六之修改变量

——因为__block就是为了在block代码块中修改外部auto类型的局部变量的值而设计的!

 

三、结论

【1】在block代码块中修改外部auto类型的局部变量的值:用static修饰、设置为全局变量、__block修饰;

【2】static修饰和设置为全局变量弊端:持续占有内存,不利于内存的高效利用;变量的生命周期不可控——__block反之;

【3】__block不能修饰static变量和全局变量;

注:以上对局部实例对象也适用——此处就不再论证了!

 

四、拓展——查找age地址值

//代码

void test4()
{
    __block int age = 10;
    block = ^{
        age = 20;
        nslog(@"%d", age);
    };
    
    nslog(@"%p", &age);
}

//打印

2019-01-15 17:58:15.930081+0800 mj_test[5583:308759] 0x100701f38
2019-01-15 17:58:15.930453+0800 mj_test[5583:308759] 20
program ended with exit code: 0

分析:打印出的age地址,据上述分析,到底是新生成的oc对象本身的地址,还是该对象结构体内成员变量age的值?

//代码

struct __block_byref_age_0 {
    void *__isa;
    struct __block_byref_age_0 *__forwarding;
    int __flags;
    int __size;
    int age;
};

struct __block_impl {
    void *isa;
    int flags;
    int reserved;
    void *funcptr;
};

struct __test3_block_desc_0 {
    size_t reserved;
    size_t block_size;
    void (*copy)(void);
    void (*dispose)(void);
};

struct __test4_block_impl_0 {
    struct __block_impl impl;
    struct __test3_block_desc_0* desc;
    struct __block_byref_age_0 *age;
};

block本质探寻六之修改变量

//打印

 block本质探寻六之修改变量

分析:

<1>上述block的桥接转换和&(strblock->age->age),前面的文章已经讲过,此处不再赘述;

<2>我们发现,__block_byref_age_0结构体内的成员变量age的地址和test4()方法中打印出的age的地址是一样的——也就是说,我们在oc代码中对age的操作都是对__block_byref_age_0结构体内的成员变量age的操作,这样有利于程序员的理解(苹果公司刻意隐藏底层)!

 

 

 github