block是C语言的扩充功能。带有自动变量的匿名函数

截获自动变量值
保存该自动变量的瞬间值

int main() {
    int dmy = 256;
    int val = 10;
    const char *fmt = "f";
    
    void (*blk)(void) = &__main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA, fmt, val);
    return 0;
}

block语法表达式中使用的自动变量被作为成员变量追加到了__main_block_impl_0结构体中

struct __main_block_impl_0 {
    struct __block_impl impl;
    struct __main_block_desc_0 *Desc;
    const char *fmt;
    int val;
}

使用执行block语法时的自动变量fmt和val来初始化__main_block_impl_0结构体实例。

impl.isa = &_NSConcreteStackBlock;
fmt = "f";
val = 10;

通过block使用的匿名函数，实际上被作为简单的C语音函数来处理。即自动变量瞬间值被截获

// id 为objc_object结构体的指针类型
typedef struct objc_object {
    Class isa;
} *id;

// Class 为objc_class结构体的指针类型
typedef struct objc_class *Class;
struct objc_class {
    Class isa;
};

总的来说，所谓‘截获自动变量的值’意味着在执行block语法时，block语法表达式所使用的自动变量值被保存到block的结构体实例中

// OC 类声明
@interface MyObject : NSObject {
    int val0;
    int val1;
}
@end

// 该类的对象的结构体
struct MyObject {
    Class isa;
    int val0;
    int val1;
};

MyObject类的实例变量val0和val1被直接声明为对象的结构体成员。
各类的结构体就是基于objc_class结构体的class_t结构体

struct class_t {
    struct class_t *isa;
    struct class_t *superclass;
    Cache cache;
    IMP *vtable;
    uintptr_t data_NEVER_USE;
}

在OC中，比如NSObject的class_t结构体实例，以及NSMutableArray的class_t结构体实例等，均生成并保持各个类的class_t结构体实例。该实例持有声明的成员变量、方法的名称、方法的实现（即函数指针）、属性以及父类的指针。

// block结构体
struct __main_block_impl_0 {
    void *isa;
    int Flags;
    int Reserved;
    void *FuncPtr;
    struct __main_block_desc_0 *Desc;
}

此__main_block_impl_0结构体相当于基于objc_objct结构体的OC类对象的结构体。
对其中的成员变量 isa 进行初始化
isa = &_NSConcreteStackBlock;
即_NSConcreteStackBlock相当于class_t结构体实例，在将block作为OC的对象处理时，关于该类的信息放置于_NSConcreteStackBlock中。所以block的实质就是OC的对象

__block

__block同block一样变成__Block_byref_val_o结构体类型的自动变量，即栈上生成的__Block_byref_val_0结构体实例。该变量初始化为10，且这个值也出现在结构体的初始化中，这意味着该结构体持有相当于原自动变量的成员变量。

__block int val = 10;
void (^blk)(void) = ^{val = 1;};

// 编译器代码
struct __Block_byref_val_0 {
    void *__isa;
    __Block_byref_val_0 * __forwarding;
    int val;
}

struct __main_block_impl_0 {
    __Block_byref_val_0 *val;
    ...
}

block的__main_block_impl_0结构体实例持有指向__block变量的__Block_byref_val_0结构体实例的指针。
__Block_byref_val_0结构体实例的成员变量__forwarding持有指向该实例自身的指针
另外，__block变量的__Block_byref_val_0结构体并不在Block的__main_block_impl_0结构体中。这样做是为了在多个Block中使用同一__block变量。

Block存储

typedef int (^blk_t)(int);
blk_t blk = ^(int count){return count};
不截获自动变量的值，放置在程序的数据区，其他的block放置在栈上

block超出变量作用域可存在的原因 ？
__block变量用结构体成员变量__forwarding存在的原因 ？
配置在全局变量上的block，从变量作用域外也可以通过指针安全的使用，但设置在栈上的block，__block变量，如果其所属的变量作用域结束，该block，__block变量就被废弃。
将配置在栈上的block复制到堆上，这样即使block变量的作用域结束，堆上的block还可以继续存在。
复制到堆上的block将_NSConcreteMallocBlock类对象写入block的结构体实例的成员变量isa
impl.isa = &_NSConcreteMallocBlock;
__block变量用结构体成员变量__forwarding可以实现无论__block变量配置在栈上还是堆上，都能正确的访问__block变量。在__block变量配置在堆上时，只要栈上的结构体实例成员变量__forwarding指向堆上的结构体实例。

一般编译器自行判断是否将block从栈上copy到堆上
编译器不能进行判断的情况：向方法或函数的参数中传递block时
下面的方法或函数不用手动复制
1.Cocoa框架的方法且方法名中含有usingBlock
NSArray enumerateObjectsUsingBlock
2.CGD 的API
dispatch_async函数

- (id)getBlockArray{
    int val = 10;
    return [[NSArray alloc] initWithObjects: ^{NSLog(@"blk0:%d",val);},
                                                       ^{NSLog(@"blk1:%d",val);}, nil];
}

- (void)testBlock{
    id obj = getBlockArray();
    typedef void (^blk_t) (void);
    blk_t blk = (blk_t)[obj objectAtIndex:0];
    blk(); // 异常
}
// getBlockArray 函数执行结束时，栈上的Block已被废弃

// 修正 如果block不截取自动变量则可正确运行
- (id)getBlockArray{
    int val = 10;
    return [[NSArray alloc] initWithObjects: [^{NSLog(@"blk0:%d",val);} copy],
                                                       [^{NSLog(@"blk1:%d",val);} copy], nil];
}

block类 | 副本源的配置存储域 | 复制效果
------- | -------
_NSConcreteStackBlock | 栈 | 从栈复制到堆
_NSConcreteGlobalBlock | 程序的数据区 | 什么也不做
_NSConcreteMallocBlock | 堆 | 引用计数增加

不管block配置在何处，用copy方法复制都不会引起任何问题，在不确定时调用copy即可

__block变量存储域

将栈上的__block变量结构体实例复制到堆上时，会将成员变量_forwarding的值替换为复制目标堆上的__block变量结构体实例的地址