block基本使用和底层

block基础使用语法

 

一、block与函数的对比

定义函数指针

int (*myFn)();

定义Blocks

int (^MyBlocks)(int,int); 

调用函数指针

(*myFn)(10, 20);

l调用Blocks

MyBlocks(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内部实现
【浅显的说就是 ->创建Block时，内部就是创建一个对应的函数；调用Block，内部调用了之前封装的函数 它的实质是函数指针 void(*block)() ，实现的核心就是回调】
利用LLVM编译器 ->clang命令 [打开终端 cd 你的文件 然后clang你需要的.m文件

• 开始解释正文：

  //举例演示：
   int a = 10;    
    __block int b = 20;     
    void (^block)() = ^(){                 
        printf("a = %d
  ",a);                  
        printf("b = %d
  ",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
",a);
        printf("b = %d
",(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/