block 又称之为“自带变量的匿名函数”,抛开OC语法定义block的形式不谈,其实好多语言都有类似的函数,比如JS的回调函数(其实就是将一个匿名还是作为函数的实参)、swift的闭包等等。。 
首先讲一下oc block的实质,通过自身的理解,加以各位大神的剖析文章。block 在编译时期会被编译成结构体,也就是说OC的block底层是使用C语言结构体实现的, 和对象、类的实现是一样的(所以其实block就是OC中的一个对象),这个结构体包括两个结构体成员变量和一个构造函数,我们都知道Objective-C是用OC实现底层的,所以我们需要将代码转化为底层的实现(使用Clang -rewrite-objc [文件名], 这个命令是将OC语言转化成C或者C++的代码,经常使用这个命令我们窥探OC的底层奥秘)

.m 源码
#import <Foundation/Foundation.h>
int main(int argc, char * argv[]) {
void (^myBlock)(void) = ^{
NSLog(@"hello world");
};
myBlock();
return 0;
}
 
clang 转化成的过程源码
 
// 此结构体 存储了block的isa指针,还有函数指针(调用的时候正是找到此函数指针进行调用)
struct __block_impl {
void *isa;
int Flags;
int Reserved;
void *FuncPtr;
};
// block函数执行体转化
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
 
NSLog((NSString *)&__NSConstantStringImpl__var_folders_dr_jkts5c395zs9xcx0bt_r7fx40000gn_T_main_7d68a8_mi_0);
}
// 内存管理的结构体
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)};
 
// 转化之后的main函数,我们可以看到block被转化成了一个函数调用,这个函数正是 __main_block_impl_0 机构体的一个构造函数,所以block被转化成了一个 __main_block_impl_0 类型的结构体; 我们看到构造函数传入了两个参数,一个函数指针,一个是结构体__main_block_desc_0实例
int main(int argc, char * argv[]) {
 
// 其实这句话就是一个指针的赋值,将一个__main_block_impl_0结构体的指针赋值给我们定义的变量myBlock,从这里可以看,OC的block会转化成一个__main_block_impl_0类型结构体
void (*myBlock)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA));
// block 的调用, 这句代码的意思是找出__main_block_impl_0结构体的imp结构体(即是一个__block_impl的结构体)然后调用其函数指针FuncPtr,从而调用block内的函数执行体(当然这是过程代码,并没有直接标出myBlock.imp.FuncPtr)
((void (*)(__block_impl *))((__block_impl *)myBlock)->FuncPtr)((__block_impl *)myBlock);
 
return 0;
}
// block的结构体 ,包含两个结构体和一个构造函数,
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;
}
};

上面的源码转换成C代码之后,我做了一次完全的剖析,我们可以得出的结论就是,block 的实现其实就是一个结构体,而其的调用则是调用结构体内的函数指针调用函数;下面我将稍微改动一下代码,看一下生成的底层代码,研究一下,截获的外部变量的情况:

我只将不同的代码提出来
.m源代码
int main(int argc, char * argv[]) {
int a = 10;
void (^myBlock)(void) = ^{
NSLog(@"hello world %d", a);
};
myBlock();
return 0;
}
clang 转换C代码
// 我们看出来了这个时候__main_block_func_0的结构体的构造函数,多传了一个变量a的参数,我们看到,并没有把a的变量指针传递,而是将变量的值传递
int main(int argc, char * argv[]) {
int a = 10;
void (*myBlock)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, a));
((void (*)(__block_impl *))((__block_impl *)myBlock)->FuncPtr)((__block_impl *)myBlock);
 
return 0;
}
 
// block 函数执行体当然也会变了,生成了一个变量,这个变量是__main_block_impl_0结构体里的变量a
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
int a = __cself->a; // bound by copy
 
NSLog((NSString *)&__NSConstantStringImpl__var_folders_dr_jkts5c395zs9xcx0bt_r7fx40000gn_T_main_3e8c5a_mi_0, a);
}
// 重要的结构体来了,这个结构体内生成了一个成员变量a
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
int a;
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _a, int flags=0) : a(_a) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};

那么我们可以看出,再没有任何修饰符的情况下,block截获的变量只是一个值,而并不是指针,所以,内部执行函数无法改变block外部的变量 
通过上边的例子,我们可以猜想,如果block的结构体如果可以拥有变量的指针那么,就可以修改外部变量的值了 ,所以 _ block就是做这件事情的,其实_ block的实现远比我们想象的复杂,我们看一下__block 修饰之后转换的代码:

// 我们可以看到加了__block 的变量和不加的变量发生明显的变化,加了__block的变量明显被转化成了一个结构体__Block_byref_c_0, 而且__main_block_impl_0block的结构体正是吧__Block_byref_c_0结构体类型的指针传入了
int main(int argc, char * argv[]) {
int a = 10;
int b = 20;
__attribute__((__blocks__(byref))) __Block_byref_c_0 c = {(void*)0,(__Block_byref_c_0 *)&c, 0, sizeof(__Block_byref_c_0), 30};
void (*myBlock)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, a, b, (__Block_byref_c_0 *)&c, 570425344));
((void (*)(__block_impl *))((__block_impl *)myBlock)->FuncPtr)((__block_impl *)myBlock);
 
return 0;
}
// 加了__block 的变量被转化的结构提类型
struct __Block_byref_c_0 {
void *__isa;
__Block_byref_c_0 *__forwarding;
int __flags;
int __size;
int c;
};
 
// block的结构体也形成了一个__Block_byref_c_0结构体指针
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
int a;
int b;
__Block_byref_c_0 *c; // by ref
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _a, int _b, __Block_byref_c_0 *_c, int flags=0) : a(_a), b(_b), c(_c->__forwarding) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
// block的执行函数 也相应的生成了一个C结构体的指针指向block结构的C
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
__Block_byref_c_0 *c = __cself->c; // bound by ref
int a = __cself->a; // bound by copy
int b = __cself->b; // bound by copy
 
NSLog((NSString *)&__NSConstantStringImpl__var_folders_dr_jkts5c395zs9xcx0bt_r7fx40000gn_T_main_55b164_mi_0, a, b, (c->__forwarding->c));
}
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {_Block_object_assign((void*)&dst->c, (void*)src->c, 8/*BLOCK_FIELD_IS_BYREF*/);}
 
static void __main_block_dispose_0(struct __main_block_impl_0*src) {_Block_object_dispose((void*)src->c, 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),

所以我们可以看得出来_ block 的作用是生成外部变量的指针,从而达到在block内部可以修改的目的;下一篇文章将会结合这篇文章Block的本质,总结_ weak _ block _ strong的使用。 
致谢:https://blog.csdn.net/abc649395594/article/details/47086751 
https://www.jianshu.com/p/fdd7fa9a9e7e 
两篇文章的对我的帮助!