block 是 Objective-C 對閉包(Closure)的實作。要真正理解它,得先弄清楚記憶體分佈、結構體定義、變數捕獲方式,以及編譯器到底做了什麼。本文從這些基礎出發,最後整理幾個常見的實務用法。
(這裡說的堆與棧是作業系統層面的記憶體分區,與資料結構中的堆、棧不是同一回事。)

一個由 C/C++/Objective-C 編譯出的程式,記憶體大致分為:
int b;,系統會自動在棧上配置空間。
// main.cpp
int a = 0; // 全域初始化區
char *p1; // 全域未初始化區
int 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"); // 複製一份字串到堆區
return 0;
}
其中 strcpy 的原型為 extern char *strcpy(char *dest, const char *src);,功能是把 src 起頭、以 NULL 結尾的字串複製到 dest 起始的位址空間。
鏈表是常見的基礎資料結構,分為單向、雙向與循環鏈表。單向鏈表最簡單,每個節點含兩個部分:資訊域(儲存節點資料)與指標域(儲存下一個節點的位址)。上面提到的空閒記憶體鏈表,其資訊域存的就是空閒位址。

結構體是 C 語言中的一種資料結構,可宣告為變數、指標或陣列,用來表達較複雜的資料。它由若干「成員(member)」組成,成員可以是不同型別,一般以名稱存取。
struct tag {
member-list
} variable-list;
struct:關鍵字tag:結構體標籤member-list:成員列表variable-list:一併宣告的變數列表這三部分至少要出現兩個:
// 有三個成員,並宣告了一個變數 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;
成員的存取有兩種方式:直接存取用於結構體變數(s1.a),間接存取用於指標(s2->a 或 (*s2).a)。
struct EXAMPLE { int a; char b; };
struct EXAMPLE s1, *s2;
s1.a = 5; // 注意 s1.a 與 s2->a 是不同成員
s1.b = 6;
s2->a = 3;
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;
});
}
按一般作用域規則,funA 不該存取到 funB 的區域變數 str。之所以能,就是因為閉包特性。
block 就是 Objective-C 對閉包的實作。
// 宣告一個 block 原型:名稱 myBlock,接收一個 int,回傳 NSString *
NSString * (^myBlock)(int);
// 定義它的內容
myBlock = ^(int paramA) {
return [NSString stringWithFormat:@"Passed number: %i", paramA];
};
// 像一般函式一樣呼叫(別忘了定義後面那個分號)
myBlock(7);
由於 block 的型別寫法會嚴重影響可讀性,實務上常用 typedef 取個有語義的名字:
// Person.h
#import <Foundation/Foundation.h>
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 <Foundation/Foundation.h>
void logBlock(int (^theBlock)(void))
{
NSLog(@"Closure var X: %i", theBlock());
}
int main(void)
{
@autoreleasepool {
int (^myBlock)(void);
int x = 42;
myBlock = ^(void) {
return x; // 存取 main 中的區域變數
};
logBlock(myBlock); // 會印出 42
}
return EXIT_SUCCESS;
}
block 宣告在 main 中,卻在 logBlock 內執行,仍然讀得到 x。block 同樣可以存取全域變數,包含 static 變數。
對於 block 外部的區域變數,block 預設是把值複製到自己的資料結構中:

因此這些變數在 block 內是唯讀的。以下寫法會編譯失敗:
myBlock = ^(void) {
x++; // 編譯錯誤:x 在 block 中為唯讀
return x;
};
若真的需要在 block 內修改外部區域變數,用 __block 修飾該變數:
__block int x;
加了 __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)*/
};
各欄位意義:
isa 指標指向的類別,決定 block 存在哪裡、生命週期多長:
_NSConcreteGlobalBlock——全域靜態 block,不存取任何外部變數,也不涉及複製:
int main() {
^{ printf("Hello, World!\n"); }();
return 0;
}
_NSConcreteStackBlock——存在棧上的 block,函式返回時即被銷毀:
int main() {
char a = 'A'; // block 存取了外部變數,所以有閉包行為
^{ printf("%c\n", a); }();
return 0;
}
_NSConcreteMallocBlock——存在堆上的 block,引用計數歸零時才銷毀。這種類型的 block 全部是由 Stack 類型複製到堆上而來:
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)(void) = [array objectAtIndex:0];
block(); // 這裡已是 Malloc 類型
}
整理三者的關係:
這也解釋了為什麼把 block 存進集合類別(陣列、字典)或作為屬性時,系統會自動觸發 copy——因為不複製的話,離開原本的 scope 就變成指標指向已失效的記憶體。
#import <Foundation/Foundation.h>
typedef void (^BlockA)(void);
// 加上 noinline,避免優化器把 runBlockA 內嵌,導致看不到呼叫過程
__attribute__((noinline))
void runBlockA(BlockA block) {
block();
}
void doBlockA() {
BlockA block = ^{
// 空的 block
};
runBlockA(block);
}
編譯器實際產生的等價程式碼:
#import <Foundation/Foundation.h>
__attribute__((noinline))
void runBlockA(struct Block_layout *block) {
block->invoke(); // 透過函式指標間接呼叫
}
void block_invoke(struct Block_layout *block) {
// 空的 block 函式
}
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);
}
對照 3.1 的結構定義,編譯器的作為就很清楚了:把 block 字面語法降解成一個結構體實例,把 block 內容變成一個普通 C 函式,呼叫時則透過 invoke 指標間接跳轉。
如果想在往後繼續使用某個 block,就必須把它從棧複製到堆,這一步由 Block_copy() 完成。descriptor 中的 copy() 輔助函式會在 Block_copy() 中被呼叫,負責 retain 那些被一併複製進來的物件。
與之對應的是 Block_release(),它會呼叫 descriptor 中的 dispose() 輔助函式,執行與 copy 相反的操作,例如釋放 block 中複製的變數。
在 ARC 環境下,這兩個 C 函式基本被 copy 與 release 的物件語意取代:block 被視為物件,指派給 strong 屬性或加入集合時會自動完成複製與持有。
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];
NSLog(@"sortArray:%@", sortArray);
輸出:
sortArray:(
"abc 05",
"abc 1",
"abc 12",
"abc 13",
"abc 21"
)
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。
區域變數只能讀,不能改:
int local = 500;
void (^block)(void) = ^(void) {
// local++; ← 編譯不通過
NSLog(@"local:%d", local);
};
block();
NSLog(@"local:%d", local);
加上 __block 就能改:
__block int local = 500;
void (^block)(void) = ^(void) {
local++;
NSLog(@"local:%d", local);
};
block();
NSLog(@"local:%d", local);
輸出兩次都是 local:501——因為 block 持有的是位址,改動會反映到原本的變數上。
__weak typeof(self) weakSelf = self; 取得弱引用。__block 修飾 Objective-C 物件時,變數是被持有的,這與 C 基本型別的「複製位址」在記憶體管理含意上不同,容易造成非預期的 retain cycle。@property (nonatomic, copy) void (^handler)(void);,這是為了確保 block 從棧複製到堆,離開當前 scope 後仍然有效。