引言:C++的魅力-浅尝block实现原理

学习C++究竟能给我们带来多大的便利，下面通过一个小的例子来演示一下。
新建一个OC命令行项目，在main函数里面这样写:

int main(int argc, char * argv[]) {
    void (^block) = ^{
        NSLog(@"Hello World");
    };
    block();
    return 0;
}

在终端clang一下(clang -rewrite-objc 源代码文件地址)，会得到main.cpp文件，你会惊到好大一坨C++代码，删除无关紧要的代码，你会发现其实也没什么嘛，这里我对剩下精华部分做了处理，再次新建了一个C++命令行项目，我把代码都粘贴到了这里，你可以尝试搞一下。看看我说的可对。

#include //输入输出头文件

// block的类型
char _NSConcreteStackBlock[2048] = "_NSConcreteStackBlock";

struct __block_impl {
    void *isa;    //指向block类型
    int Flags;    //状态
    int Reserved; //备用
    void *FuncPtr;//函数指针
};

struct __main_block_impl_0 {
    struct __block_impl impl;
    struct __main_block_desc_0 *Desc;
    
    // 含参构造函数
    __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int flags=0) {
        impl.isa = &_NSConcreteStackBlock;
        impl.Flags = flags;
        impl.FuncPtr = fp;
        Desc = desc;
    }
};
// 保存了block大小，这是一个静态类，全局只有一份
static struct __main_block_desc_0 {
    size_t reserved;
    size_t Block_size;
} __main_block_desc_0_DATA = {0, sizeof(struct __main_block_impl_0)};

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
    printf("Hello, World!\n");
}

int main(int argc, const char * argv[]) {
    // insert code here...
    // block没有那么神秘，block其实也是一个对象，只不过这个对象比较特殊。
    __main_block_impl_0 *block = new __main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA);
    ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
    return 0;
}

控制台输出结果:

Hello, World!
Program ended with exit code: 0

再来看一下block中修改外部自动变量的例子，在没有__block修饰的情况下，会出现一下的编译错误，在__block修饰的情况下，我们看看源码是如何的

Variable is not assignable (missing __block type specifier)

#import 

int main(int argc, const char *argv[]) {
  @autoreleasepool {
    __block int val = 10;

    void (^blk)(void) = ^{
      val += 1;
    };
    blk();
  }
  return 0;
}

struct __Block_byref_val_0 {
  void *__isa;
__Block_byref_val_0 *__forwarding;
 int __flags;
 int __size;
 int val;
};

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  __Block_byref_val_0 *val; // by ref
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_val_0 *_val, int flags=0) : val(_val->__forwarding) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  __Block_byref_val_0 *val = __cself->val; // bound by ref

      (val->__forwarding->val) += 1;
    }
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {_Block_object_assign((void*)&dst->val, (void*)src->val, 8/*BLOCK_FIELD_IS_BYREF*/);}

static void __main_block_dispose_0(struct __main_block_impl_0*src) {_Block_object_dispose((void*)src->val, 8/*BLOCK_FIELD_IS_BYREF*/);}

static struct __main_block_desc_0 {
  size_t reserved;
  size_t Block_size;
  void (*copy)(struct __main_block_impl_0*, struct __main_block_impl_0*);
  void (*dispose)(struct __main_block_impl_0*);
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0), __main_block_copy_0, __main_block_dispose_0};


int main(int argc, const char *argv[]) {
  /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 
    __attribute__((__blocks__(byref))) __Block_byref_val_0 val = {(void*)0,(__Block_byref_val_0 *)&val, 0, sizeof(__Block_byref_val_0), 10};

    void (*blk)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_val_0 *)&val, 570425344));
    ((void (*)(__block_impl *))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk);
  }
  return 0;
}

结论

block没有那么神秘，block其实也是一个OC对象，只不过这个对象比较特殊。

抛砖:

1.C++/C结构体的异同?
2.函数指针你真的了解吗？
3.C++结构体及类中的成员函数、构造函数、析构函数等特征？
4.OC与C++/C混编开发？
5.__block、typedef、auto、static、extern、register 存储域类说明符，这些关键字的作用是指定将变量值设置到哪个存储域中。
例如，auto表示作为自动变量（局部变量）存储在栈中
static表示作为静态变量存储在数据区中。

理解block需要弄清楚的几个问题

• Block超出变量作用域可存在的理由
• __block变量的结构体成员变量__forwarding存在的理由
• 解决循环引用的方式有几种
• 三种改变所截获变量的方式
  • 静态变量(内存地址传递)
  • 自动变量(__block截获)
  • 全局变量(取决于作用域)、静态全局变量(取决于作用域)

__forwarding存在的理由：不管__block变量配置在栈上还是堆上，都能够正确的访问该变量。