Blocks是C语言的扩充功能。可以用一句话来表示Blocks的扩充功能:带有自动变量(局部变量)的匿名函数。----------------《Objective-C高级编程》
通常,我们命名一个函数,具备函数名、参数名、返回参数名。
eg:(void*)print:(NSString*)name;
/*
*print:函数名
name:参数名
NSString * :参数类型
(void*)返回值类型,这个其实是无返回值的
*/
函数在内存中,占有一个块内存,称为代码块(或者说是函数块)。如果此时有一个指针指向了这个函数地址,我们就称这个指针就是函数指针。那么这个函数指针是什么类型呢?
盖住函数名,就是函数指针的类型;(void*)(*)(NSString *)
Block的一般写法为:void(^blk)();
Void为返回类型,blk为Block的名称,无参数传入
NSString *(^name)(NSString *)=^(NSSting * n){
NSLog(@"name is %@",n);
return n;
}
其中传入参数、返回值都为NSString。
Block一般分三步走:1、声明2、实现3、调用。
1、截获自动变量
typedef void(^blk_t)();
int i = 1;
blk_t blk_t2 = ^{
printf("i = %d\n",i);
};
blk_t2();// __NSMallocBlock__
__block int b =2;
blk_t blk_t21 = ^{
b =3;
printf("b = %d\n",b);
};
blk_t21();// __NSMallocBlock__
当我们用__block 修饰自动变量的时候,在block的内部将 自动变量编译成了结构
体,而在block中拥有指向该结构体的指针变量,从而能够修改自动变量的值
当Block从栈中复制到堆中时,相应的__block变量也会复制到堆中。此时,栈中的
__forwarding指针指向堆中的 __block变量地址。而堆中的
__block变量的__forwarding 指针指向自己。所以我们访问的 __block变量不会存在问题。
2、从栈复制到堆(摘自Objective-C高级编程)
1.调用block的copy实例方法
2.Block作为函数返回值返回时
3.将Block赋值附有__strong修饰符id类型 或Block类型成员变量时
4、在方法名中含有usingBlock 的Cocoa 框架方法或GCD的API中传递Block时
在调用Block的copy 实例方法时。如果Block配置在栈上,那么Blcok会从栈复制到堆。
Block作为函数返回值返回时、将Block赋值给附有__strong修饰符id类型的类,或者Block类型变量时,编译器自动将对象的Block作为参数并调用_Block_copy
函数,这与调用Block的copy实例方法的效果相同。
在方法名中含有usingBlock的Cocoa框架方法或GCD的API传递Block时,在该方法或函数内部堆传递过来的Block调用Block的copy实例方法 或者 ——Block_copy函数
通过使用-__ strong 修饰符的自动变量,Block中截获的对象就能超出其变量作用域而存在
3、__weak弱引用防止内存泄漏
一般滴,我们在block中调用self.prop或者self时,用__weak来修饰指针变量
Id _weak tmp = self;
Blk =^{NSLog(@"self = %@",tmp)};
这样就能解决循环引用的问题
4、使用__block修饰 防止内存泄露
#import"MyObject.h"
typedef void(^blk_t)(void);
@interface MyObject()
{
blk_t blk_;
}
@end
@implementationMyObject
- (instancetype)init
{
self= [super init];
if(self) {
__block id tmp =self;
blk_= ^{
NSLog(@"self =%@",tmp);
tmp= nil;
};
}
return self;
}
- (void)execBlcok{
blk_();
}
@end
intmain(intargc,const char* argv[]) {
@autoreleasepool{
id obj = [[MyObject alloc]init];
[obj execBlcok];
}
}
该源码没有引起循环引用。但是不调用execBlock方法,即不能执行赋值给成员变量blk_的Block,就会循环引用,并引起内存泄漏。
1、MyObject持有Block
2、Block持有__block变量
3、__block变量持有MyObject对象
调用execBlock方法,Block实例被执行,nil会被复制到__block变量的tmp中
此时,__block变量tmp对MyObject类对象的强引用失效。避免了循环引用
1、MyObject持有Block
2、Block持有__block变量
使用__block变量的优点:
1、通过__block变量可控制对象的持有
期间
2、在不能使用__weak修饰符的环境中不使用_unsafe_unretained
修饰符即可(不用担心悬垂指针)
在执行Block时可动态地决定是否将nil或者其他对象赋值在__block变量中
缺点:
为了避免循环引用必须执行Block
Block的链式编程
Block的链式编程能够较少代码量,让代码更加简洁。
#import
@interfaceChainObject :NSObject
- (ChainObject*(^)(NSString*))name;
- (ChainObject*(^)(NSString*))write;
@end
#import"ChainObject.h"
@implementationChainObject
- (ChainObject*(^)(NSString*))name{
return^(NSString* n){
NSLog(@"他是%@",n);
return self;
};
}
- (ChainObject*(^)(NSString*))write{
return^(NSString* w){
NSLog(@"他能写%@",w);
return self;
};
}
@end
int main(intargc,const char* argv[]) {
@autoreleasepool{
ChainObject *c = [[ChainObject alloc]init];
c.name(@"小明").write(@"书法");
}
}
那么我们来思考一下,Block链式编程中,是否会有内存泄漏么?
这样是不存在循环引用的。