关于这方面的内容其实满天飞，但每篇都几乎是一样子的，可能大多数人都觉得自己讲的特别清楚，但是其实很多内容都让读者觉得作者说的云里雾里，不知所云。今天尝试从0开始一直到block讲的清清楚楚为止。
我们使用

clang -rewrite-objc -fobjc-arc -stdlib=libc++ -mmacosx-version-min=10.7 -fobjc-runtime=macosx-10.7 -Wno-deprecated-declarations main.m

命令重写以下代码,看一下各种类型的变量变成C++后是什么样子。

1、int 类型变量

#import <Foundation/Foundation.h>

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        int a = 1;
    }
    return 0;
}

重写后生成的C++代码多大9万多行，不过没关系，我们把文件拉到最后，直接看这里

int main(int argc, const char * argv[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 
        int a = 1;
    }
    return 0;
}

这几万行代码的上面都是 #import <Foundation/Foundation.h>
首先是 @autoreleasepool 语法糖被重写成了 __AtAutoreleasePool __autoreleasepool 这里暂时先不探究 @autoreleasepool的问题，先看一下变量的情况，可以看到下面并没有发生什么变化，仍然是 int a = 10;符合预期因为这本来就是 C 语法嘛。

2、__block 修饰的 int 类型变量

这里就有点意思了，我们声明一个带__block修饰的变量如下

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        __block int a = 1;
    }
    return 0;
}

同样执行上述命令编译成C++代码如下：

struct __Block_byref_a_0 { // __block修饰的int变量生成的结构体
  void *__isa;
__Block_byref_a_0 *__forwarding; // 该结构体指向的实际值指针
 int __flags; // 标识位
 int __size; // 该结构体的内存大小
 int a; // 保存的实际值
};
int main(int argc, const char * argv[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 
        __attribute__((__blocks__(byref))) __Block_byref_a_0 a = {(void*)0,(__Block_byref_a_0 *)&a, 0, sizeof(__Block_byref_a_0), 1};
    }
    return 0;
}

可以看到__block int a = 1被编译成了这么多东西。参考这里
https://gist.github.com/mjhsieh/668374
可以知道 __block 其实是 __attribute__((__blocks__(byref))) 的宏，那么我们声明一个带__block的变量实际上就是声明了一个上述类型的结构体并且声明了一个该结构体的实例变量。

3、没有参数没有返回值的block 的声明

我们声明一个block如下

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        void(^block)(void) = ^() {
            
        };
    }
    return 0;
}

编译成C++代码如下

struct __block_impl { // block 的实现
    void *isa;
    int Flags;
    int Reserved;
    void *FuncPtr; // 函数指针
};

struct __main_block_impl_0 { // main 函数中 block 的实现
  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; // 该 block 所指向的函数指针，真正调用block的时候实际上是执行的该函数
    Desc = desc;// block 的描述信息
  }
};
// 实际函数,由于这个block并不会执行任何代码，所以该函数里并没有任何东西。该函数的参数只有一个，即传入该结构体的实例。
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {


        }

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)};
int main(int argc, const char * argv[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 
      //这里执行的是该结构体的构造函数，将上述函数和block的描述结构体传入，构造一个block变量。
        void(*block)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA));
    }
    return 0;
}

可以看到最后生成了三个结构体和一个静态函数。其中最主要的就是__main_block_impl_0这个结构体
，里面保存着该block实际调用的函数的指针和该block的描述信息。描述信息主要记录着该block的大小。

4、有参数没有返回值的block 的声明和执行

我们试着将如下代码转成C++代码来看

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        void(^block)(int) = ^(int a) {
            NSLog(@"%d", a);
        };
        block(2);
    }
    return 0;
}

C++ 代码如下

int main(int argc, const char * argv[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 
        void(*block)(int) = ((void (*)(int))&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA));
        ((void (*)(__block_impl *, int))((__block_impl *)block)->FuncPtr)((__block_impl *)block, 2);
    }
    return 0;
}

可以看到执行block的实际含义其实是调用该block中保存的函数指针，然后将该block以及block需要的参数传入即可，即执行了该函数。

5、block 引用普通变量

OC代码如下

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        int b = 1;
        void(^block)(void) = ^{
            NSLog(@"%d", b);
        };
        block();
    }
    return 0;
}

编译成的C++代码如下

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

            NSLog((NSString *)&__NSConstantStringImpl__var_folders_p0_xw8yd5qj1rd_0pyjtn4g0t7h0000gn_T_main_ec2b7f_mi_0, b);
        }

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)};
int main(int argc, const char * argv[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 
        int b = 1;
        void(*block)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, b));
        ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
    }
    return 0;
}

可以看到block生成的结构体中有了block里使用的变量的值，即block拷贝了该变量到自己的结构体里面,这也是当block声明之后再修改变量的值，block里的变量不会变化的原因。因为要执行的函数已经确定了，相应的值也是确定的，外面再修改已经没有用了，因为block对于普通变量执行的是值拷贝的操作。

6、__block 修饰的变量在block中使用的场景

OC代码如下

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        __block int b = 1;
        void(^block)(void) = ^{
            NSLog(@"%d", b);
        };
        b = 2;
        block();
    }
    return 0;
}

编译后生成的C++代码如下

int main(int argc, const char * argv[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 
        __attribute__((__blocks__(byref))) __Block_byref_b_0 b = {(void*)0,(__Block_byref_b_0 *)&b, 0, sizeof(__Block_byref_b_0), 1};
        void(*block)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_b_0 *)&b, 570425344));
        (b.__forwarding->b) = 2;
        ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
    }
    return 0;
}

可以看到传入block执行函数的是__block int b 生成的结构体，改变b的值其实是改变的该结构体中的b的值，当执行该函数的时候传入的参数是该结构体的值，所以block执行的时候可以拿到最新的值。