上一回我們談了 Blocks 的語法,這次來看編譯器究竟把 Block 變成了什麼。方法很簡單:用 clang 轉換原始碼,觀察它生成的 C 程式。
int main() {
void (^blk)(void) = ^{ printf(); };
blk();
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;
__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;
}
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
printf();
}
static struct __main_block_desc_0 {
unsigned long reserved;
unsigned long Block_size;
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0) };
int main() {
void (*blk)(void) = (void (*)(void))&__main_block_impl_0(
(void *)__main_block_func_0, &__main_block_desc_0_DATA);
((void (*)(struct __block_impl *))((struct __block_impl *)blk)->FuncPtr)((struct __block_impl *)blk);
return 0;
}
可以看到,Block 使用的匿名函數實際上被轉換成了一個普通的 C 函式。函式名稱的組成規則是「所屬函式名 + 該 Block 在函式中出現的順序」。
Block 語法 ^{ printf(); } 對應:
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
printf();
}
參數 __cself 的角色等同於 C++ 的 this 與 Objective-C 的 self,它是 __main_block_impl_0 結構體的指標。
結構體本身由兩個成員組成:impl(__block_impl 型別)與 Desc(指向 __main_block_desc_0)。其中 __block_impl 保留了 flags 與 reserved 區域供未來擴充使用,並有一個函式指標 FuncPtr;Desc 則記錄保留區域與 Block 本身的大小。
構造函式中出現的 _NSConcreteStackBlock,是用來初始化 isa 成員的。
void (*blk)(void) = (void (*)(void))&__main_block_impl_0(
(void *)__main_block_func_0, &__main_block_desc_0_DATA);
拆成兩步就一目了然:
struct __main_block_impl_0 tmp = __main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA); struct __main_block_impl_0 *blk = &tmp;
也就是在堆疊上產生 __main_block_impl_0 結構體實例,再把它的指標賦給 blk。第一個參數是由 Block 語法轉換而來的 C 函式指標,第二個參數是以靜態全域變數初始化的 Desc 實例指標,並以結構體大小作為初始化內容。
最終各成員的值為:
isa = &_NSConcreteStackBlock; Flags = 0; Reserved= 0; FuncPtr = __main_block_func_0; Desc = &__main_block_desc_0_DATA;
((void (*)(struct __block_impl *))((struct __block_impl *)blk)->FuncPtr)((struct __block_impl *)blk); // 去掉轉型後 (*blk->impl.FuncPtr)(blk);
這就是最單純的函式指標呼叫。__cself 指向 Block 值,也就是把 Block 本身當成參數傳進去。
關鍵在 isa = &_NSConcreteStackBlock。回頭看 id 的定義:
struct objc_class { Class isa; };
typedef struct objc_class *Class;
typedef struct objc_object { Class isa; } *id;
宣告一個 Objective-C 類別:
@interface MyObject : NSObject {
int val0;
int val1;
}
@end
它的物件結構體相當於:
struct MyObject {
Class isa;
int val0;
int val1;
};
也就是說,在 Objective-C 中「由類別產生物件」,意味著產生該類別對應的結構體實例,每個物件透過成員變數 isa 保有所屬類別結構體實例的指標。

各類別的結構體則是基於 objc_class 的 class_t:
struct class_t {
struct class_t *isa;
struct class_t *superclass;
Cache cache;
IMP *vtable;
uintptr_t data_NEVER_USE;
};
NSObject、NSMutableArray 等每個類別都會產生並保有各自的 class_t 實例,其中放著成員變數宣告、方法名稱、方法實作(函式指標)、屬性以及父類別指標,供 Objective-C 執行期函式庫使用。
對照回 Block 的結構體,它與 objc_object 結構完全同構;_NSConcreteStackBlock 的角色就是 class_t 實例,當 Block 被當成 Objective-C 物件處理時,關於該「類別」的資訊就放在其中。結論:Block 就是 Objective-C 物件。
轉換後的程式碼如下:
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0 *Desc;
const char *fmt;
int val;
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc,
const char *_fmt, int _val, int flags = 0)
: fmt(_fmt), val(_val) {
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 &fmt = __cself->fmt;
int val = __cself->val;
printf(fmt, val);
}
int main() {
int dmy = 256;
int val = 10;
const char *fmt = "val = %d\n";
void (*blk)(void) = &__main_block_impl_0(
__main_block_func_0, &__main_block_desc_0_DATA, fmt, val);
return 0;
}
重點有兩個:
__main_block_impl_0 的成員變數(此例是 val 與 fmt)。未被使用的自動變數不會被追加,截獲只針對 Block 中實際用到的變數。因此 Block 表達式中的 printf(fmt, val) 完全不需要改寫,就能讀到被截獲下來的值。這就是「保存執行 Block 語法瞬間的自動變數值」的實作方式。
最後補充一點:Block 不能直接使用 C 陣列型別。因為在構造函式中把陣列參數賦值給成員變數這件事本身,在 C 語言裡就不合法(陣列不能指派),所以 Block 也無法截獲 C 陣列。
前面提到,在 Block 中修改自動變數會編譯失敗,因為 Block 只截獲了「值」。要在 Block 中保存或修改外部變數,有幾條路。
int global_val = 1;
static int static_global_val = 2;
int main() {
static int static_val = 3;
void (^blk)(void) = ^{
global_val *= 1;
static_global_val *= 2;
static_val *= 3;
};
return 0;
}
轉換後可以看到,全域變數與靜態全域變數完全沒有被改動,而靜態區域變數則是以指標的形式被訪問:
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;
global_val *= 1;
static_global_val *= 2;
(*static_val) *= 3;
}
int main() {
static int static_val = 3;
blk = &__main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA, &static_val);
return 0;
}
把靜態變數的指標傳給構造函式並保存,是「在離開作用域後仍能使用該變數」最簡單的做法。
__block 是一種「儲存類別類說明符」。C 語言的儲存類別類說明符有 typedef、extern、static、auto、register,它們用來指定變數存放在哪一種儲存區域。__block 的性質與此類似。
__block int val = 10;
void (^blk)(void) = ^{ val = 1; };
編譯後程式碼變得相當長:
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;
__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;
(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(&dst->val, src->val, BLOCK_FIELD_IS_BYREF);
}
static void __main_block_dispose_0(struct __main_block_impl_0 *src) {
__Block_object_dispose(src->val, BLOCK_FIELD_IS_BYREF);
}
static struct __main_block_desc_0 {
unsigned long reserved;
unsigned long 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() {
__Block_byref_val_0 val = { 0, &val, 0, sizeof(__Block_byref_val_0), 10 };
blk = &__main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA, &val, 0x22000000);
return 0;
}
關鍵在於:帶 __block 的變數也變成了結構體型別的自動變數,也就是在堆疊上產生的 __Block_byref_val_0 實例,原本的值 10 成為該結構體成員的初始值。這個結構體持有等同於原自動變數的成員變數 val。
赋值時的程式碼 ^{ val = 1; } 轉換成:
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
__Block_byref_val_0 *val = __cself->val;
(val->__forwarding->val) = 1;
}
相較於靜態變數只是傳遞並解引用指標,__block 變數的處理更為複雜:Block 的結構體實例持有指向 __Block_byref_val_0 實例的指標,而該實例的 __forwarding 成員又持有指向自身的指標,透過 __forwarding 才能存取到真正等價於原自動變數的 val。

至於 __forwarding 為什麼要多這一層間接,牽涉到 Block 從堆疊複製到堆上時的所有權搬移,這個議題值得再單獨用一篇來說明。