Block 是 Objective-C 中極具威力的特性之一,但要真正用好它,必須先打好底層基礎。本文將從記憶體結構講起,逐步深入到 Block 的語法、閉包特性,乃至編譯器背後的運作機制。
需要先說明的是,這裡探討的堆與棧屬於記憶體分配層面的概念,與資料結構中的堆、棧並不相同。
一段由 C/C++/Objective-C 編譯後的程序,其記憶體大致可劃分為以下幾個區域:

棧區(stack):由系統自動分配與釋放,通常用來存放函數的參數值與區域變數。當你在函數中宣告一個區域變數 int b; 時,系統便會自動在棧中為它開闢空間,遵循後進先出的原則。
堆區(heap):由程式設計師主動申請並指定大小,也需自行釋放;若忘記釋放,則可能在程式結束時由作業系統回收。作業系統以鏈表方式管理堆區,當收到分配請求時,會遍歷記錄空閒位址的鏈表,找到合適的節點後將其分配給程式。
例如在 C 語言中:
char *p1;
p1 = (char *)malloc(10);
// 但值得注意的是,指標 p1 本身位於棧中。
鏈表是一種常見的基礎資料結構,分為單向、雙向與循環鏈表。單向鏈表最為簡單,每個節點包含一個資訊域與一個指標域,前者儲存資料,後者儲存下一個節點的位址。

全局區/靜態區:顧名思義,用來存放全域變數與靜態變數。已初始化的存放在一塊,未初始化的存放在另一塊,程式結束後由系統釋放。
文字常量區:主要存放字串常量,程式結束後由系統釋放。
程式代碼區:存放函數體的二進位碼。
下面這個經典範例能幫助你理清各區域的歸屬:
//main.cpp
int a = 0; // 全域初始化區
char *p1; // 全域未初始化區
main {
int b; // 棧
char s[] = "abc"; // 棧
char *p2; // 棧
char *p3 = "123456"; // 123456\0 在常量區,p3 在棧上
static int c = 0; // 全域靜態初始化區
p1 = (char *)malloc(10);
p2 = (char *)malloc(20); // 分配的 10 和 20 位元組區域位於堆區
strcpy(p1, "123456"); // 將字串複製到 p1 申請的堆區域中
}
補充一下 strcpy 函數:其原型為 extern char *strcpy(char* dest, const char *src);,功能是將 src 起始且以 NULL 結尾的字串複製到 dest 起始的位址空間。
結構體是 C 語言中的一種資料結構,可宣告為變數、指標或陣列,用於實現較複雜的資料組織。它由若干成員組成,成員可以是不同型別,通常以名稱訪問。
其定義形式如下:
struct tag { member-list } variable-list;
一般情況下,上述三部分至少要出現兩個。以下提供幾種典型寫法:
// 擁有 a、b、c 三個成員,並宣告變數 s1,但未標明標籤
struct{
int a;
char b;
double c;
} s1;
// 擁有同樣三個成員,標明標籤 EXAMPLE,但未宣告變數
struct EXAMPLE{
int a;
char b;
double c;
};
// 使用 EXAMPLE 標籤,另外宣告 t1、t2 陣列與 t3 指標
struct EXAMPLE t1, t2[20], *t3;
結構體的成員可以包含其他結構體,也可以包含指向自身型別的指標。
成員訪問分為兩種方式:普通結構體變數採用直接訪問(變數名.成員名),指向結構體的指標採用間接訪問((*指標名).成員名 或 指標名->成員名)。
struct EXAMPLE{
int a;
char b;
};
struct EXAMPLE s1, *s2;
s1.a = 5;
s1.b = 6;
s2->a = 3; // 注意 s1.a 與 s2->a 並非同一成員
s2->b = 4;
成員儲存方面,編譯器按成員列表順序逐一分配記憶體。若想知道結構體佔用多少空間,可用 sizeof;若想得知某成員的偏移量,則可用 offsetof 巨集(定義於 stddef.h)。
int size_example = sizeof(struct EXAMPLE);
int offset_b = offsetof(struct EXAMPLE, b);
閉包本質上是一個函數(或指向函數的指標),再加上這個函數執行時所依賴的非區域變數。通俗地說,閉包允許一個函數訪問宣告它的執行上下文中、甚至不同上下文中的變數。
以腳本語言為例:
function funA(callback){
alert(callback());
}
function funB(){
var str = "Hello World"; // funB 的區域變數,卻是 funA 的非區域變數
funA(function(){
return str;
});
}
按常理,str 的作用域僅限於 funB,funA 無從訪問;但由於閉包特性,funA 中的 callback 卻能讀取到 str。這正是閉包的魔力所在。
Block 實際上就是 Objective-C 對閉包的實現。
先看原型:
NSString * (^myBlock)(int);
這行程式碼宣告了一個名為 myBlock 的 Block,它接收一個 int 型別參數,回傳值為 NSString 型別的指標。
接著是定義:
myBlock = ^(int paramA)
{
return [NSString stringWithFormat:@"Passed number: %i", paramA];
};
此處將一個函數體賦值給 myBlock,它接收名為 paramA 的參數並回傳一個 NSString 物件。切記不要忘記 Block 後面的分號。
定義完成後,即可像普通函數一樣調用它:myBlock(7);
由於 Block 的型別語法可讀性較差,實務上常用 typedef 為其建立語義化的別名:
// Person.h
#import
// 定義新的 Block 型別
typedef NSString * (^GetPersonEducationInfo)(NSString *);
typedef NSString * (^GetPersonFamilyInfo)(NSString *);
@interface Person : NSObject
- (NSString *)getPersonInfoWithEducation:(GetPersonEducationInfo)educationInfo
andFamily:(GetPersonFamilyInfo)familyInfo;
@end
下圖總結了 Block 的整體結構:

// .h
-(void)testBlock:(NSString * (^)(int))myBlock;
// .m
-(void)testBlock:(NSString * (^)(int))myBlock
{
NSLog(@"Block returned: %@", myBlock(7));
}
由於 Objective-C 是強制型別語言,作為參數的 Block 也必須明確指定回傳值型別與參數型別。
我們來看一段程式碼:
#import
void logBlock(int (^theBlock)(void))
{
NSLog(@"Closure var X: %i", theBlock());
}
int main(void)
{
NSAutoreleasePool *pool;
int (^myBlock)(void);
int x;
pool = [[NSAutoreleasePool alloc] init];
x = 42;
myBlock = ^(void){
return x;
};
logBlock(myBlock);
[pool release];
return EXIT_SUCCESS;
}
程式在 main 中宣告整數 x 並賦值 42,接著宣告一個回傳 42 的 Block,再將它傳給 logBlock。儘管 Block 是在 logBlock 中被執行,而它宣告於 main 之中,卻仍能訪問到 x。這正是閉包性的體現。
值得補充的是,Block 同樣可以訪問全域變數,即使是 static 修飾的變數也不例外。
對於 Block 外部的變數,Block 預設會將其複製到自己的資料結構中以实现訪問:

透過 Block 進行閉包捕獲的變數是 const 的,也就是說無法在 Block 內直接修改。若嘗試自增 x:
myBlock = ^(void){
x++;
return x;
};
編譯器會報錯,指出 x 在 Block 中為唯讀。
若確實需要在 Block 內修改變數,可使用 __block 關鍵字修飾:
__block int x;
對於以 __block 修飾的變數,Block 複製的是其引用位址而非數值本身,因而得以修改:

下圖展示了一個位於棧中的 Block 結構:

對應的結構體定義如下:
struct Block_descriptor {
unsigned long int reserved;
unsigned long int size;
void (*copy)(void *dst, void *src);
void (*dispose)(void *);
};
struct Block_layout {
void *isa;
int flags;
int reserved;
void (*invoke)(void *, ...);
struct Block_descriptor *descriptor;
/* Imported variables. */
};
其中 Block_layout 就是 Block 的結構體定義,各欄位含義如下:
Block 有幾種不同類型,各自對應一個類,也就是 isa 指標所指的對象。常見的三種類型如下:
_NSConcreteGlobalBlock:全域靜態 Block,不訪問任何外部變數,也不涉及拷貝,例如空 Block:
#include
int main()
{
^{ printf("Hello, World!\n"); }();
return 0;
}
_NSConcreteStackBlock:保存在棧中的 Block,函數返回時即被銷毀:
#include
int main()
{
char a = 'A';
^{ printf("%c\n", a); }();
return 0;
}
_NSConcreteMallocBlock:保存在堆中的 Block,引用計數為 0 時才被銷毀。這類 Block 都由 _NSConcreteStackBlock 從棧複製到堆而來。如下例中,exampleB_addBlockToArray 裡的 Block 起初為棧類型,到了 exampleB 中被複製進堆,成為 Malloc 類型:
void exampleB_addBlockToArray(NSMutableArray *array) {
char b = 'B';
[array addObject:^{
printf("%c\n", b);
}];
}
void exampleB() {
NSMutableArray *array = [NSMutableArray array];
exampleB_addBlockToArray(array);
void (^block)() = [array objectAtIndex:0];
block();
}
總結三種類型的特點:
以一段簡單示例說明:
#import
typedef void(^BlockA)(void);
__attribute__((noinline))
void runBlockA(BlockA block) {
block();
}
void doBlockA() {
BlockA block = ^{
// Empty block
};
runBlockA(block);
}
這裡定義了一個 BlockA 型別,在 doBlockA 中實現,作為 runBlockA 的參數傳入並調用。
注意:若 Block 的創建與調用都在同一函數內,優化器可能對程式碼做內聯優化,導致我們觀察不到編譯器的內部操作。因此使用 __attribute__((noinline)) 為 runBlockA 加上 noinline,避免被內聯優化。
編譯器實際所做的工作如下:
#import
__attribute__((noinline))
void runBlockA(struct Block_layout *block) {
block->invoke();
}
void block_invoke(struct Block_layout *block) {
// Empty block function
}
void doBlockA() {
struct Block_descriptor descriptor;
descriptor->reserved = 0;
descriptor->size = 20;
descriptor->copy = NULL;
descriptor->dispose = NULL;
struct Block_layout block;
block->isa = _NSConcreteGlobalBlock;
block->flags = 1342177280;
block->reserved = 0;
block->invoke = block_invoke;
block->descriptor = descriptor;
runBlockA(&block);
}
對照 Block 的資料結構定義,編譯器內部的運作便一目了然。
若想在後續繼續使用某個 Block,就必須將它從棧空間複製到堆空間,這一過程需調用 Block_copy()。Block 的 descriptor 中有一個 copy() 輔助函數,會在 Block_copy() 中執行,當 Block 需要拷貝物件時,該函數會 retain 住已拷貝的物件。
與 Block_copy() 相對應的是 Block_release(),用於釋放不再需要的 Block。descriptor 中的 dispose() 輔助函數會在 Block_release() 中執行,負責與 copy() 相反的操作,例如釋放所有在 Block 中拷貝的變數。
void (^printBlock)(NSString *x);
printBlock = ^(NSString* str)
{
NSLog(@"print:%@", str);
;
printBlock(@"hello world!");
// 輸出:print:hello world!
NSArray *stringArray = [NSArray arrayWithObjects:@"abc 1", @"abc 21", @"abc 12", @"abc 13", @"abc 05", nil];
NSComparator sortBlock = ^(id string1, id string2)
{
return [string1 compare:string2];
;
NSArray *sortArray = [stringArray sortedArrayUsingComparator:sortBlock];
// 輸出:
// sortArray:( "abc 05", "abc 1", "abc 12", "abc 13", "abc 21" )
Block 若想遞歸調用,其變數必須是全域或靜態變數,這樣程式啟動時 Block 變數便已完成初始化,得以遞歸調用:
static void (^const blocks)(int) = ^(int i)
{
if (i > 0) {
NSLog(@"num:%d", i);
blocks(i - 1);
}
;
blocks(3);
// 輸出:num:3 num:2 num:1
在 Block 中,全域變數可以被讀取和修改:
int global = 1000;
int main(int argc, const char *argv[])
{
@autoreleasepool {
void(^block)(void) = ^(void){
global++;
NSLog(@"global:%d", global);
};
block();
NSLog(@"global:%d", global);
}
return 0;
}
// 輸出:global:1001 global:1001
而區域變數可以讀取,卻不能直接修改。若要在 Block 內修改區域變數,只需在其前面加上 __block 關鍵字:
__block int local = 500;
void(^block)(void) = ^(void){
local++;
NSLog(@"local:%d", local);
;
block();
NSLog(@"local:%d", local);
// 輸出:local:501 local:501