__block修饰基本数据类型

前面我们说到,block内部改变自动变量的方法:

将自动变量转为指针传入
用__block修饰

下面分析一下__block的原理
OC中的代码如下:

#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
    __block int i = 0;
    
    void (^myBlock)(void) = ^{
        i ++;
        NSLog(@"%d",i);
    };
    i ++;
    myBlock();
    return 0;
}

打印结果是2;

从打印结果来看可以看出:block内部拿到了局部变量,而不是值传递
将上面的OC代码转化为C++如下:

// 提前定义的类型
typedef long unsigned int __darwin_size_t;
typedef __darwin_size_t size_t;

//结构体类型:__block_impl
struct __block_impl {
    //指向所属类的指针，也就是block的类型
    void *isa;
    //标志变量，在实现block的内部操作时会用到
    int Flags;
    //保留变量
    int Reserved;
    //block执行时调用的函数指针
    void *FuncPtr;
};
//__block转化的结构体
//取出这个结构体的i值0: m.__forwarding->i
struct __Block_byref_i_0 {
    void *__isa;
    //指向当前类型的结构体指针成员变量
    __Block_byref_i_0 *__forwarding;
    //标志变量
    int __flags;
    //这个结构体的大小
    int __size;
    // __block修饰的值
    int i;
};

struct __main_block_impl_0 {
    struct __block_impl impl;
    struct __main_block_desc_0* Desc;
    //与原来相比多了个该结构体指针成员变量
    __Block_byref_i_0 *i; // by ref
    __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_i_0 *_i, int flags=0) : i(_i->__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中的参数,然后进行操作
    __Block_byref_i_0 *i = __cself->i; // bound by ref
    (i->__forwarding->i) ++;
    
    NSLog((NSString *)&__NSConstantStringImpl__var_folders_g__2b0bh4bx0p13dn6mxjdd8sq00000gn_T_main_8ec3b5_mi_0,(i->__forwarding->i));
}
/*******辅助函数copy与dispose*********/
//在捕获变量为__block修饰的基本类型，或者为对象时，block才会有这两个辅助函数。
//保留捕获的对象
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {_Block_object_assign((void*)&dst->i, (void*)src->i, 8/*BLOCK_FIELD_IS_BYREF*/);}

//释放捕获的对象
static void __main_block_dispose_0(struct __main_block_impl_0*src) {_Block_object_dispose((void*)src->i, 8/*BLOCK_FIELD_IS_BYREF*/);}

//创建并初始化该结构体
static struct __main_block_desc_0 {
    //保留字段
    size_t reserved;
    //结构体__main_block_impl_0的大小
    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[]) {
    //__block int i = 0的转换
    /*
     初始化一个结构体i
     void *__isa; =>(void*)0
     __Block_byref_i_0 *__forwarding; =>(__Block_byref_i_0 *)&i
     int __flags;=> 0
     int __size;=>sizeof(__Block_byref_i_0)
     int i;=> 0
     */
    __attribute__((__blocks__(byref))) __Block_byref_i_0 i = {(void*)0,(__Block_byref_i_0 *)&i, 0, sizeof(__Block_byref_i_0), 0};
    //初始化一个函数指针变量(实质是一个结构体指针变量)
    //注意点:__main_block_impl_0这个结构体构造函数传入的可是(__Block_byref_i_0 *)&i,这是__Block_byref_i_0类型的结构体指针
    void (*myBlock)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_i_0 *)&i, 570425344));
    //i++; 转化
    (i.__forwarding->i) ++;
     //函数的调用
    //__main_block_func_0 (myBlock);
    ((void (*)(__block_impl *))((__block_impl *)myBlock)->FuncPtr)((__block_impl *)myBlock);
    return 0;
}

分析如下:

将__block int i ;包装成一个__Block_byref_i_0类型的结构体i
然后将这个结构体指针(注意是指针)作为参数之一初始化成另一个结构体__main_block_impl_0
当调用结构体时:myBlock();
- __main_block_impl_0通过其成员变量拿到__main_block_func_0函数
- __main_block_func_0函数根据其参数(__main_block_impl_0类型),拿到成员变量__Block_byref_i_0 *i;
- 根据该类型(__Block_byref_i_0)结构体指针拿到存储值进行操作:
  (i->__forwarding->i) ++;

结论:__block作用就是把整型变量i包装成一个结构体,然后以结构体指针的形式进行传递,说白了宗旨还是把值传递变相的改为地址传递

__block修饰对象类型

这里就不分析c++了,太麻烦,直接看打印吧

ARC

OC代码:

//以下代码是在ARC下执行的
#import <Foundation/Foundation.h>

int main(int argc, const char * argv[]) {

    __block id block_obj = [[NSObject alloc]init];
    id obj = [[NSObject alloc]init];

    NSLog(@"block_obj = [%@ , %p] , obj = [%@ , %p]",block_obj , &block_obj , obj , &obj);

    void (^myBlock)(void) = ^{
        NSLog(@"***Block中****block_obj = [%@ , %p] , obj = [%@ , %p]",block_obj , &block_obj , obj , &obj);
    };

    myBlock();

    return 0;
}

打印结果:

block_obj = [<NSObject: 0x100b027d0> , 0x7fff5fbff7e8] , obj = [<NSObject: 0x100b03b50> , 0x7fff5fbff7b8]
Block**中*block_obj = [<NSObject: 0x100b027d0> , 0x100f000a8] , obj = [<NSObject: 0x100b03b50> , 0x100f00070]

现象:block_obj与obj地址都发生了变化,说明block对其都进行了copy操作

MRC

打印结果如下:

block_obj = [<NSObject: 0x100b001b0> , 0x7fff5fbff7e8] , obj = [<NSObject: 0x100b001c0> , 0x7fff5fbff7b8]
Block**中*block_obj = [<NSObject: 0x100b001b0> , 0x7fff5fbff7e8] , obj = [<NSObject: 0x100b001c0> , 0x7fff5fbff790]

现象:obj地址都发生了变化,block_obj没有还是原来的对象

结论:

对于基本数据类型来说:
- 捕获是必须在Block结构体__main_block_impl_0里面有成员变量，Block能捕获的变量就只有带有自动变量和静态变量了。捕获进Block的对象会被Block持有。
- 而剩下的静态全局变量，全局变量，函数参数，也是可以在直接在Block中改变变量值的，但是他们并没有变成Block结构体__main_block_impl_0的成员变量，因为他们的作用域大，所以可以直接更改他们的值。
对于对象来说:
- 无__block修饰
  无论是ARC还是MRC，Block捕获外部对象变量，都会copy一份，地址都不同。也就是说retainCount+1
- __block修饰
  - 在MRC环境下，__block根本不会对指针所指向的对象执行copy操作，而只是把指针进行的复制。也就是说retainCount不变
  - 而在ARC环境下，对于声明为__block的外部对象，在block内部会进行retain，也就是说retainCount+1