block 解析 - 成员变量

回顾

在 上一篇 中我们讲了截获变量特性，对于局部变量，变量不加__block修饰符，在block内部是无法修改变量的值。而且

1. 对值类型的修改，如果block初始化后，无法同步到block内部
2. 对于指针类型的修改，如果block初始化后，修改指针指向，即指向另外一块内存，这样也是无法同步到block内部
3. 对于指针类型的修改，如果block初始化后，对指针指向的内存进行修改，即NSMutableArray add 、remove操作，这样是可以用同步到block内部，但block内部同样无法修改。

成员变量

对于成员变量，结果却不一样，加了__block和不加__block修饰符效果都是一样的，而且不用区分是引用类型和值类型，block初始化后，对于block内部引用的变量的修改，也能同步到block内部,并且在block内部可以修改成员变量的值。

Demo：

声明两个变量：_person2、_person3

@interface KDBlockTest()
{
    NSString *_person2;
    __block NSString *_person3;
}

添加测试方法，输出变量的值、地址、指针地址

-(void )test3
{
    _person2=@"person2";
    _person3=@"person3";
    //初始值
    NSLog(@"init _person2:%@,%p",_person2,_person2);
    NSLog(@"init _person3:%@,%p",_person3,_person3);
    void (^myBlock)(int) = ^(int num) {
        //block内赋值
        _person3=@"person33";
        NSLog(@"excuteing _person2:%@,%p",_person2,_person2);
        NSLog(@"excuteing _person3:%@,%p",_person3,_person3);
    };
    //修改前赋值
    _person2=@"person22";
    NSLog(@"excutebefore _person2:%@,%p",_person2,_person2);
    NSLog(@"excutebefore _person3:%@,%p",_person3,_person3);
    myBlock(1);
    //block执行后
    NSLog(@"excuteafter _person2:%@,%p",_person2,_person2);
    NSLog(@"excuteafter _person3:%@,%p",_person3,_person3);
}

 

执行结果如下：

2014-07-29 12:06:11.526 Test[2575:60b] init _person2:person2,0x10790c
2014-07-29 12:06:11.529 Test[2575:60b] init _person3:person3,0x10791c
2014-07-29 12:06:11.530 Test[2575:60b] excutebefore _person2:person22,0x10797c
2014-07-29 12:06:11.531 Test[2575:60b] excutebefore _person3:person3,0x10791c
2014-07-29 12:06:11.532 Test[2575:60b] excuteing _person2:person22,0x10797c
2014-07-29 12:06:11.534 Test[2575:60b] excuteing _person3:person33,0x10794c
2014-07-29 12:06:11.535 Test[2575:60b] excuteafter _person2:person22,0x10797c
2014-07-29 12:06:11.536 Test[2575:60b] excuteafter _person3:person33,0x10794c

从日志可以看出，

1. block内部修改了成员变量_person3（没有用__block修饰符），并且同步到block外部，修改前和修改后地址是一样的。
2. block初始化后，执行前，修改成员变量_person2的值，可以同步到block内部（没有用__block修饰符），修改前和修改后地址是一样的。

我们来看一下clang转换后的代码就会知道原因了

struct __KDBlockTest__test3_block_impl_0 {
  struct __block_impl impl;
  struct __KDBlockTest__test3_block_desc_0* Desc;
  KDBlockTest *self;
  __KDBlockTest__test3_block_impl_0(void *fp, struct __KDBlockTest__test3_block_desc_0 *desc, KDBlockTest *_self, int flags=0) : self(_self) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

对于局部变量，block结构体里对应一个变量，都会有一个成员。

对于成员变量，block结构体里只会有一个成员变量，即 KDBlockTest *self，不管你是否用__block修饰了，此时对self产生了强引用

void (*myBlock)(int) = (void (*)(int))&__KDBlockTest__test3_block_impl_0((void *)__KDBlockTest__test3_block_func_0, &__KDBlockTest__test3_block_desc_0_DATA, self, 570425344);

在初始化的时候，把self传到block结构体构造函数里，block对象对self产生了引用，此时我们对成员变量进行修改

_person2=@"person22";
_person3=@"person33";

转换后代码

 (*(NSString **)((char *)self + OBJC_IVAR_$_KDBlockTest$_person2))=(NSString *)&__NSConstantStringImpl__var_folders_5l_2l25j3tn0wl_3zy1hpsq1rhc0000gp_T_KDBlockTest_3beba7_mi_8;

这段代码大致是修改self的objc变量。下面开始执行block，即调用对应的函数指针。

((void (*)(__block_impl *, int))((__block_impl *)myBlock)->FuncPtr)((__block_impl *)myBlock, 1);

static void __KDBlockTest__test3_block_func_0(struct __KDBlockTest__test3_block_impl_0 *__cself, int num) {
  KDBlockTest *self = __cself->self; // bound by copy


        (*(NSString **)((char *)self + OBJC_IVAR_$_KDBlockTest$_person3))=(NSString *)&__NSConstantStringImpl__var_folders_5l_2l25j3tn0wl_3zy1hpsq1rhc0000gp_T_KDBlockTest_3beba7_mi_5;
        NSLog((NSString *)&__NSConstantStringImpl__var_folders_5l_2l25j3tn0wl_3zy1hpsq1rhc0000gp_T_KDBlockTest_3beba7_mi_6,(*(NSString **)((char *)self + OBJC_IVAR_$_KDBlockTest$_person2)),(*(NSString **)((char *)self + OBJC_IVAR_$_KDBlockTest$_person2)));
        NSLog((NSString *)&__NSConstantStringImpl__var_folders_5l_2l25j3tn0wl_3zy1hpsq1rhc0000gp_T_KDBlockTest_3beba7_mi_7,(*(NSString **)((char *)self + OBJC_IVAR_$_KDBlockTest$_person3)),(*(NSString **)((char *)self + OBJC_IVAR_$_KDBlockTest$_person3)));
    }

函数实现里通过引用block结构体的成员self，再引用到对应的objc变量_person2和_person3。

小结:

1. 对于一个、多个成员变量，不管是否用__block修饰（用不用都没任何影响），block结构体会生成一个成员 :self,并且会引用成员变量所属的对象实例 self。
2. 对于成员变量的修改都是通过对象self指针引用来实现的。
3. block内部对于成员变量的访问也是通过block结构体对象的成员self 指针引用来实现的。

 

转载于:https://www.cnblogs.com/NarutoYq/p/3873090.html