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\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/