這次來聊聊 Block 是如何截獲自動變量的,以及 __block 背後的原理到底是什麼。
直接上代碼:
#include "stdio.h"
int main(){
int a = 100;
int b = 200;
const char *ch = "b = %d\n";
void (^block)(void) = ^{
printf(ch, b);
};
b = 300;
ch = "value had changed.b = %d\n";
block();
return 0;
}
底層轉換後的代碼如下:
struct __block_impl {
void *isa;
int Flags;
int Reserved;
void *FuncPtr;
};
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
const char *ch;
int b;
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, const char *_ch, int _b, int flags=0) : ch(_ch), 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) {
const char *ch = __cself->ch; // bound by copy
int b = __cself->b; // bound by copy
printf(ch, 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 a = 100;
int b = 200;
const char *ch = "b = %d\n";
void (*block)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, ch, b));
b = 300;
ch = "value had changed.b = %d\n";
((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
return 0;
}
基本結構在第一篇已經介紹完了,這裡重點看截獲帶來的變化。
1. 先看 Block 的內部結構本尊,以及截獲後的區別
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
const char *ch;
int b;
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, const char *_ch, int _b, int flags=0) : ch(_ch), b(_b) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
根據 main 函數中的 Block 語法,這裡把 Block 表達式裡用到的局部變量,作為成員變量追加到了 __main_block_impl_0 結構體中。
值得注意的是:
@ 結構體內聲明的成員變量類型與局部變量完全相同。
@ 語法中沒有用到的局部變量(例如這裡的 a)不會被追加。
@ 這裡截獲的 ch 是不可修改的,而且捕捉到的 b 只是截獲了該局部變量的值而已。
2. 再看該結構體實例化的構造函數與調用
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, const char *_ch, int _b, int flags=0) : ch(_ch), b(_b) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
void (*block)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, ch, b));
傳給構造函數的參數,用來對由局部變量追加的成員變量進行初始化。這裡傳入的僅僅是 ch 和 b 的值,可理解為把 Block 表達式裡截獲的局部變量追加到 __main_block_impl_0 的成員並賦值。初始化後:
impl.isa = &_NSConcreteStackBlock;
impl.Flags = 0;
impl.FuncPtr = __main_block_func_0;
Desc = &__main_block_desc_0_DATA;
ch = "b=%d\n";
b = 200;
由此可見,__main_block_impl_0 這個結構體(即 Block 本體)對自動變量進行了截獲。
3. 最後看調用 Block 時的區別
((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
const char *ch = __cself->ch; // bound by copy
int b = __cself->b; // bound by copy
printf(ch, b);
}
可以看出 block() 這句調用轉換後的方式沒有任何變化,仍是 (*block->impl.FuncPtr)(block),並把結構體本身作為參數傳遞。
現在注意 __main_block_func_0 這個 C 函數:它對傳入的 block 結構體參數進行變量獲取 __cself->ch 和 __cself->b(這兩個變量已在 Block 表達式之前聲明),最終打印出來。
一句話總結:所謂「截獲自動變量」,無非就是在執行 Block 語法時,把用到的局部變量值保存到 Block 的結構體實例(即 Block 本體)當中。
仔細看就會發現,Block 捕獲的變量就像「帶有局部變量值的匿名函數」,僅僅截獲局部變量的值。如果在 Block 內部改寫局部變量,並不會改變原先截獲的值。例如:
int a = 0;
void (^block)(void) = ^{ a = 1 };
這樣寫會直接編譯報錯!從 __main_block_impl_0 的實現上也能看出,它並不允許改寫捕獲變量的值。

簡單分隔一下:上面介紹了值的捕獲,那麼如何解決在 Block 中修改值?
第一種方法:運用 C 語言中的變量
@ 靜態變量
@ 靜態全局變量
@ 全局變量
#include "stdio.h"
int global_val = 1; // 全局變量
static int static_global_val = 2; // 靜態全局
int main(){
static int static_val = 3; // 靜態局部
void (^block)(void) = ^{
global_val *= 1;
static_global_val *= 2;
static_val *= 3;
};
block();
printf("%d\n", global_val);
printf("%d\n", static_global_val);
printf("%d\n", static_val);
}
全局變量和靜態全局變量問題不大,出了作用域照樣能訪問;但靜態局部變量若去掉 static,按上面那種寫法就會報錯,原因就是實現上不能改寫捕獲的局部變量的值。
那能改寫的情況是什麼呢?答案是讓 Block 截獲局部變量的指針。看 clang 源碼:
int global_val = 1;
static int static_global_val = 2;
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
int *static_val;
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int *_static_val, int flags=0) : static_val(_static_val) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
int *static_val = __cself->static_val; // bound by copy
global_val *= 1;
static_global_val *= 2;
(*static_val) *= 3;
}
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(){
static int static_val = 3;
void (*block)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, &static_val));
((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
printf("%d\n", global_val);
printf("%d\n", static_global_val);
printf("%d\n", static_val);
}
區別很明顯:
@ __main_block_impl_0 結構體中追加的成員變量變成了 int *static_val 指針。
@ 結構體實例化時傳入的參數也變為 &static_val 地址。
也就是說,Block 語法轉換而來的 C 靜態函數通過 static_val 的指針來訪問;初始化時把靜態變量的地址傳給結構體並保存,這是超出作用域使用變量最簡單的方法。
第二種方法:使用大家熟知的 __block 修飾符
__block int a = 0;
void (^block)(void) = ^{ a = 1 };
把之前編譯報錯的代碼加上 __block 修飾符,再讓 clang 轉成源碼看看,代碼量直接暴增,又能展開好幾篇分析。

struct __Block_byref_a_0 {
void *__isa;
__Block_byref_a_0 *__forwarding;
int __flags;
int __size;
int a;
};
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
__Block_byref_a_0 *a; // by ref
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_a_0 *_a, int flags=0) : a(_a->__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_a_0 *a = __cself->a; // bound by ref
(a->__forwarding->a) = 1;
}
static void __main_block_copy_0(struct __main_block_impl_0 *dst, struct __main_block_impl_0 *src) {
_Block_object_assign((void*)&dst->a, (void*)src->a, 8/*BLOCK_FIELD_IS_BYREF*/);
}
static void __main_block_dispose_0(struct __main_block_impl_0 *src) {
_Block_object_dispose((void*)src->a, 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(){
__attribute__((__blocks__(byref))) __Block_byref_a_0 a = {(void*)0, (__Block_byref_a_0 *)&a, 0, sizeof(__Block_byref_a_0), 0};
void(*blk)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_a_0 *)&a, 570425344));
return 0;
}
分析一個 __block 多了這麼多代碼和結構,著實讓人眼花。__block int a = 0; 分解為:
__Block_byref_a_0 a = {(void*)0, (__Block_byref_a_0 *)&a, 0, sizeof(__Block_byref_a_0), 0};
加上了 __block 後,a 變成了一個結構體實例,在棧上生成了 __Block_byref_a_0 結構體實例,a 初始化為 0,這個值也出現在結構體的成員變量中,意味著該結構體持有相當於原局部變量的成員變量。
來看看它的結構:
struct __Block_byref_a_0 {
void *__isa;
__Block_byref_a_0 *__forwarding;
int __flags;
int __size;
int a;
};
其中最後一個 int a 就是原局部變量的成員變量。
再看 void (^block)(void) = ^{ a = 1 }; 分解為:
void(*blk)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_a_0 *)&a, 570425344));
仍是調用 __main_block_impl_0 的初始化,但由於 a 加了 __block 修飾符,傳入的不再是 &a 的地址,而是換成 __Block_byref_a_0 結構體實例的指針(該結構體也是個對象,最後的屬性放著需要截獲的局部變量)。
對應的 block 塊函數轉換為 C:
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
__Block_byref_a_0 *a = __cself->a; // bound by ref
(a->__forwarding->a) = 1;
}
對比兩個方案:第一個用 C 語言的靜態變量,直接操作靜態變量的指針即可;而 __block 則複雜得多。Block 的結構體實例持有指向 __block 變量 __Block_byref_a_0 結構體實例的指針。
__Block_byref_a_0 結構體實例的成員變量 __forwarding 持有指向該結構體實例自身的指針,通過 __forwarding 訪問成員變量 a。
來一張示意圖幫助理解:


另外要提一點,__block 內部的 __Block_byref_a_0 也是獨立的結構體實例,不屬於 __main_block_impl_0 結構體,這樣便於在多個 Block 中都能訪問同一個 __block 變量。
後續預告:Block 超出作用域變量仍能存在的理由、__forwarding 存在的理由,以及源碼中新增的 copy 和 dispose 函數,之後再細看。
總結
1. 普通局部變量被 Block 截獲只是單純截獲其值,並追加到 __main_block_impl_0 結構體中(無法修改重寫)。
2. 要允許 Block 修改值有兩個方法:一是用 C 語言的變量(代表是靜態局部變量),二是用 __block 修飾符。
3. __block 修飾的變量其實變成了對象結構體 __Block_byref_a_0,初始化 __main_block_impl_0 時追加的是這個結構體的指針。
4. 最終在 __main_block_func_0 中調用 __block 結構體指針的 forwarding 指針(此時指向自己)的成員變量 a 來重新賦值。
5. __block 生成的源碼,大致能看出類似 OC 中對象 retain/release 的一系列操作,下一節再細看。
一句話概括:__block 修飾的局部變量其實也是一個結構體實例(對象),並且以結構體指針作為參數進行初始化和調用。