您现在的位置: IOS教程網 >> IOS系統 >  >> iOS 教學 >> iOS 相關教學

Objective-C block 深入解析:閉包、變數捕獲與編譯器視角

編輯:iOS 相關教學

block 是 Objective-C 對閉包(Closure)的實作。要真正理解它,得先弄清楚記憶體分佈、結構體定義、變數捕獲方式,以及編譯器到底做了什麼。本文從這些基礎出發,最後整理幾個常見的實務用法。

一、先備概念

1.1 記憶體的分佈

(這裡說的堆與棧是作業系統層面的記憶體分區,與資料結構中的堆、棧不是同一回事。)

一個由 C/C++/Objective-C 編譯出的程式,記憶體大致分為:

  • 棧區(stack):由系統自動配置與釋放,存放函式參數、區域變數等。行為類似資料結構中的棧。例如在函式中宣告 int b;,系統會自動在棧上配置空間。
  • 堆區(heap):由程式設計師申請並決定大小,也必須自行釋放;若不釋放,程式結束時可能由 OS 回收。堆由鏈表管理:OS 維護一份空閒記憶體位址的鏈表,收到配置請求時遍歷該鏈表,找到第一個大於申請大小的節點,將其從鏈表移除並把位址交給程式。
  • 全域區/靜態區:存放全域變數與靜態變數。已初始化的與未初始化的各自集中一塊,程式結束後由系統釋放。
  • 文字常量區:存放字串常量,程式結束後由系統釋放。
  • 程式碼區:存放函式體的二進位碼。
// 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 起始的位址空間。

1.2 鏈表

鏈表是常見的基礎資料結構,分為單向、雙向與循環鏈表。單向鏈表最簡單,每個節點含兩個部分:資訊域(儲存節點資料)與指標域(儲存下一個節點的位址)。上面提到的空閒記憶體鏈表,其資訊域存的就是空閒位址。

1.3 結構體(struct)

結構體是 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);

1.4 閉包(Closure)

閉包就是「一個函式(或指向函式的指標)+這個函式所依賴的非區域變數」。說得白一點:閉包允許一個函式存取宣告它的那個執行環境中的變數。

function funA(callback) {
    alert(callback());
}

function funB() {
    var str = "Hello World"; // funB 的區域變數,卻是 funA 的非區域變數
    funA(function() {
        return str;
    });
}

按一般作用域規則,funA 不該存取到 funB 的區域變數 str。之所以能,就是因為閉包特性。

二、block 基礎

block 就是 Objective-C 對閉包的實作。

2.1 原型與定義

// 宣告一個 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 的結構可以這樣理解:

2.2 把 block 當參數傳遞

// .h
- (void)testBlock:(NSString * (^)(int))myBlock;

// .m
- (void)testBlock:(NSString * (^)(int))myBlock
{
    NSLog(@"Block returned: %@", myBlock(7));
}

Objective-C 是強制型別語言,所以作為參數的 block 也必須明確標示回傳值與參數型別。

2.3 閉包性的實際樣貌

#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 變數。

2.4 變數的複製與修改

對於 block 外部的區域變數,block 預設是把值複製到自己的資料結構中:

因此這些變數在 block 內是唯讀的。以下寫法會編譯失敗:

myBlock = ^(void) {
    x++;        // 編譯錯誤:x 在 block 中為唯讀
    return x;
};

若真的需要在 block 內修改外部區域變數,用 __block 修飾該變數:

__block int x;

加了 __block 之後,block 複製的是變數的參考位址,因此可以透過指標修改原值:

三、編譯器眼中的 block

3.1 資料結構

對應的結構體定義:

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 類型的類物件
  • flags:按 bit 位標記附加資訊,例如 block 類型、引用計數、是否需要執行輔助函式等
  • reserved:保留欄位,可理解為 block 內部變數的數量
  • invoke:函式指標,指向 block 實際實作的位址
  • descriptor:附加描述,包含保留變數數、block 大小,以及 copy/dispose 的輔助函式指標
  • variables:因為有閉包性,這裡放的是被複製進來的外部變數值或位址

3.2 block 的三種類型

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 類型
}

整理三者的關係:

  1. Global:要麼是空 block,要麼不存取任何外部變數。既不在棧也不在堆,相當於放在全域區。
  2. Stack:有閉包行為,且因為棧空間會被重複使用,只能執行一次,之後就被清出棧外。
  3. Malloc:有閉包行為,且需要被多次執行。當需要跨函式存活時,就會從棧複製到堆上。

這也解釋了為什麼把 block 存進集合類別(陣列、字典)或作為屬性時,系統會自動觸發 copy——因為不複製的話,離開原本的 scope 就變成指標指向已失效的記憶體。

3.3 編譯器實際做了什麼

#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 指標間接跳轉。

3.4 copy() 與 dispose()

如果想在往後繼續使用某個 block,就必須把它從棧複製到堆,這一步由 Block_copy() 完成。descriptor 中的 copy() 輔助函式會在 Block_copy() 中被呼叫,負責 retain 那些被一併複製進來的物件。

與之對應的是 Block_release(),它會呼叫 descriptor 中的 dispose() 輔助函式,執行與 copy 相反的操作,例如釋放 block 中複製的變數。

在 ARC 環境下,這兩個 C 函式基本被 copy 與 release 的物件語意取代:block 被視為物件,指派給 strong 屬性或加入集合時會自動完成複製與持有。

四、實戰範例

4.1 參數為 NSString * 的 block

void (^printBlock)(NSString *x);
printBlock = ^(NSString *str) {
    NSLog(@"print:%@", str);
};
printBlock(@"hello world!");

輸出:print:hello world!

4.2 用 block 排序陣列

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"
)

4.3 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 在初始化的那一刻還沒有被賦值,無法參照到自己。

4.4 在 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 持有的是位址,改動會反映到原本的變數上。

五、實務上的幾個提醒

  • 循環參照:若物件強持有某個 block,而 block 內又強引用該物件(例如直接使用 self),就會形成循環參照導致記憶體洩漏。此時在 block 內改用 __weak typeof(self) weakSelf = self; 取得弱引用。
  • __block 在 ARC 下的物件語意:以 __block 修飾 Objective-C 物件時,變數是被持有的,這與 C 基本型別的「複製位址」在記憶體管理含意上不同,容易造成非預期的 retain cycle。
  • block 屬性用 copy:物件屬性宣告 block 時慣例寫 @property (nonatomic, copy) void (^handler)(void);,這是為了確保 block 從棧複製到堆,離開當前 scope 後仍然有效。
  • 避免在 block 中做重活:block 常用於非同步回呼,若在其中執行大量運算而沒有切回背景佇列,一樣會卡住主執行緒。
  1. 上一篇文章:
  2. 下一篇文章:
蘋果刷機越獄教程| IOS教程問題解答| IOS技巧綜合| IOS7技巧| IOS8教程
Copyright © IOS教程網 All Rights Reserved