Block 深入学习
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链式编程中，是否会有内存泄漏么？
这样是不存在循环引用的。
