__block修饰基本数据类型
前面我们说到,block内部改变自动变量的方法:
- 将自动变量转为指针传入
- 用__block修饰
下面分析一下__block的原理
OC中的代码如下:
#import
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
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 = [ , 0x7fff5fbff7e8] , obj = [ , 0x7fff5fbff7b8]
Block**中*block_obj = [ , 0x100f000a8] , obj = [ , 0x100f00070]
现象:block_obj与obj地址都发生了变化,说明block对其都进行了copy操作
MRC
打印结果如下:
block_obj = [ , 0x7fff5fbff7e8] , obj = [ , 0x7fff5fbff7b8]
Block**中*block_obj = [ , 0x7fff5fbff7e8] , obj = [ , 0x7fff5fbff790]
现象:obj地址都发生了变化,block_obj没有还是原来的对象
结论:
- 对于基本数据类型来说:
- 捕获是必须在Block结构体
__main_block_impl_0里面有成员变量，Block能捕获的变量就只有带有自动变量和静态变量了。捕获进Block的对象会被Block持有。 - 而剩下的静态全局变量，全局变量，函数参数，也是可以在直接在Block中改变变量值的，但是他们并没有变成Block结构体
__main_block_impl_0的成员变量，因为他们的作用域大，所以可以直接更改他们的值。
- 捕获是必须在Block结构体
- 对于对象来说:
- 无__block修饰
无论是ARC还是MRC，Block捕获外部对象变量，都会copy一份，地址都不同。也就是说retainCount+1 - __block修饰
- 在MRC环境下，__block根本不会对指针所指向的对象执行copy操作，而只是把指针进行的复制。也就是说retainCount不变
- 而在ARC环境下，对于声明为__block的外部对象，在block内部会进行retain，也就是说retainCount+1
- 无__block修饰
Block的循环引用
从上面可以看到,Block会捕获下面3中类型的数据:
- 局部变量
- 静态变量
- 对象
也就是说如果self(某个控制器)有一个block属性,并且self有又上面三种类型的属性,而且block内部使用了上面的3个变量(不管是self.还是_引用),那么就会产生循环引用了