block基本使用和底层
block基础使用语法
int (*myFn)();
int (^MyBlocks)(int,int);
(*myFn)(10, 20);
二、Block 语法：
1.作为当地变量：
returnType (^blockName)(parameterTypes) = ^returnType(parameters) { ... ... }
2.作为属性:
@property (nonatomic,copy) returnType (^blockName)(parameterTypes)
3.作为方法参数:
-(void)someMethodThatTakesABlock:( returnType (^)(parameterTypes) )blockName
4.作为方法调用的参数：
［someObject someMethodThatTakesABlock:^returnType(parameters){ ... ... } ];
5.作为typeDef:
typedef returnType(^typeName)(parameterTypes)
TypeName blockName = ^returnType(parameters) { ... ... };
例子：
block要掌握的东西
1> 如何定义block变量
int (^sumBlock)(int, int);
void (^myBlock)();
2> 如何利用block封装代码
^(int a, int b) {
return a - b;
};
^() {
NSLog(@"----------");
};
^ {
NSLog(@"----------");
};
3> block访问外面变量
* block内部可以访问外面的变量
* 默认情况下，block内部不能修改外面的局部变量
* 给局部变量加上__block关键字，这个局部变量就可以在block内部修改
* block访问全局变量时应先把全局变量赋值给局部变量
3.1>循环引用：
block 被copy之后，该block会对他捕获到的对象产生Strong引用，如果self引用的block，block捕获了self，将会造成内存循环
解决方法
__weak weakSelf = self;
__weak typeof(self) weakSelf = self(弱引用);
4> 利用typedef定义block类型
typedef int (^MyBlock)(int, int);
// 以后就可以利用MyBlock这种类型来定义block变量
MyBlock block;
MyBlock b1, b2;
b1 = ^(int a, int b) {
return a - b;
};
MyBlock b3 = ^(int a, int b) {
return a - b;
};
【浅显的说就是 ->创建Block时，内部就是创建一个对应的函数；调用Block，内部调用了之前封装的函数 它的实质是函数指针 void(*block)() ，实现的核心就是回调】
利用LLVM编译器 ->clang命令 [打开终端 cd 你的文件 然后clang你需要的.m文件
- 开始解释正文：
//举例演示： int a = 10; __block int b = 20; void (^block)() = ^(){ printf("a = %d\n",a); printf("b = %d\n",b); }; a = 50; b = 30; block();//常用的runtime中终端clang命令 clang -rewrite-objc main.m 结果： int main(int argc, const char * argv[]) { int a = 10; //__block修饰，封装到结构体__Block_byref_b_0 __attribute__((__blocks__(byref))) __Block_byref_b_0 b = {(void*)0,(__Block_byref_b_0 *)&b, 0, sizeof(__Block_byref_b_0), 20}; //传入到结构体struct __main_block_impl_0 的__main_block_impl_0(...){...}中 void (*block)() = (void(*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, a, (__Block_byref_b_0 *)&b, 570425344); a = 50; //结构体属性值重新指向 (b.__forwarding->b) = 30; //获取结构体属性FuncPtr。也就是封装后的block方法体。然后传入block实例，执行打印 ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block); return 0; }
-----------> 分析编译出来的C++代码
-->1、
__attribute__((__blocks__(byref))) __Block_byref_b_0 b = {(void*)0,(__Block_byref_b_0 *)&b, 0, sizeof(__Block_byref_b_0), 20};参数：
(void*)0
(__Block_byref_b_0 *)&b
0
sizeof(__Block_byref_b_0)
20把b的值 封装到 Block_byref_b_0结构体中。【block修饰的值装在封装的结构体中】
struct __Block_byref_b_0 {
void *__isa; //当前对象指针
__Block_byref_b_0 *__forwarding; //当前结构体指针，__forwarding 存储自己地址。用__block修饰便执行
int __flags; //标记
int __size; // 结构体大小
int b; // 值
};-->2、传递到结构体中的方法里
void (*block)() = (void(*)())&__main_block_impl_0(
(void *)__main_block_func_0, &__main_block_desc_0_DATA, a, (__Block_byref_b_0 *)&b, 570425344
);传递：
(void *)__main_block_func_0 // 存储block方法体【这里就是两条打印】，下文的 *fp
&__main_block_desc_0_DATA // 地址，block的描述数据
a // 值传递
(__Block_byref_b_0 *)&b //传递 b的地址，结构体包装
570425344到：block的实例方法
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
int a; // 10
__Block_byref_b_0 *b; // by ref
//调用这个方法，方法的实现在括号内.上文传递的参数在此赋值
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _a, __Block_byref_b_0 *_b, int flags=0) : a(_a), b(_b->__forwarding) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp; //执行的代码 打印。__main_block_func_0
Desc = desc;
}
}block内的方法封装到这里
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
__Block_byref_b_0 *b = __cself->b; // bound by ref
int a = __cself->a; // bound by copy
printf("a = %d\n",a);
printf("b = %d\n",(b->__forwarding->b));
}
struct __block_impl {
void *isa;
int Flags;
int Reserved;
void *FuncPtr;
};-->3、
a = 50;
(b.__forwarding->b) = 30;
//这里的b 是 __Block_byref_b_0 b
//在结构体中获得属性__forwarding，并给它指向值 30；//特别提醒：
使用__block 就是传地址 / 不使用就是传值
反编译成C++ 后发现，当使用了__block 修饰对象的时候，都会封装成一种类型的结构体。
block的简单实用：http://blog.csdn.net/u014536527/article/details/50378586
block的高级：http://blog.devtang.com/2013/07/28/a-look-inside-blocks/
