您现在的位置: IOS教程網 >> IOS系統 >  >> iOS 程式開發 >> iOS 開發綜合

深入掌握 Objective-C 中 Block 代碼塊的原理與實踐

編輯:iOS 開發綜合

Block 是 Objective-C 中極具威力的特性之一,但要真正用好它,必須先打好底層基礎。本文將從記憶體結構講起,逐步深入到 Block 的語法、閉包特性,乃至編譯器背後的運作機制。

一、先備概念

1.1 操作系統中的堆與棧

需要先說明的是,這裡探討的堆與棧屬於記憶體分配層面的概念,與資料結構中的堆、棧並不相同。

一段由 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 起始的位址空間。

1.2 結構體(Struct)

結構體是 C 語言中的一種資料結構,可宣告為變數、指標或陣列,用於實現較複雜的資料組織。它由若干成員組成,成員可以是不同型別,通常以名稱訪問。

其定義形式如下:

struct tag { member-list } variable-list;

  • 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);

1.3 閉包(Closure)

閉包本質上是一個函數(或指向函數的指標),再加上這個函數執行時所依賴的非區域變數。通俗地說,閉包允許一個函數訪問宣告它的執行上下文中、甚至不同上下文中的變數。

以腳本語言為例:

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

按常理,str 的作用域僅限於 funB,funA 無從訪問;但由於閉包特性,funA 中的 callback 卻能讀取到 str。這正是閉包的魔力所在。

二、Block 基礎知識

Block 實際上就是 Objective-C 對閉包的實現。

2.1 Block 的原型與定義

先看原型:

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 的整體結構:

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
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 修飾的變數也不例外。

2.4 Block 中變數的複製與修改

對於 Block 外部的變數,Block 預設會將其複製到自己的資料結構中以实现訪問:

透過 Block 進行閉包捕獲的變數是 const 的,也就是說無法在 Block 內直接修改。若嘗試自增 x:

myBlock = ^(void){
    x++;
    return x;
};

編譯器會報錯,指出 x 在 Block 中為唯讀。

若確實需要在 Block 內修改變數,可使用 __block 關鍵字修飾:

__block int x;

對於以 __block 修飾的變數,Block 複製的是其引用位址而非數值本身,因而得以修改:

三、編譯器中的 Block

3.1 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 的結構體定義,各欄位含義如下:

  • isa:指向表明 Block 類型的類。
  • flags:以 bit 位表示 Block 的附加資訊,如 Block 類型、引用計數、是否需要執行輔助函數等。
  • reserved:保留變數,一般理解為 Block 內部變數的數量。
  • invoke:函數指標,指向 Block 具體實現的函數調用位址。
  • descriptor:Block 的附加描述資訊,如保留變數數、Block 大小,以及 copy/dispose 輔助函數指標。
  • variables:由於 Block 具備閉包性,可訪問外部區域變數,這些欄位即為複製進結構體的外部變數或其位址。

3.2 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();
}

總結三種類型的特點:

  1. _NSConcreteGlobalBlock:要麼是空 Block,要麼不訪問任何外部變數,既不在棧也不在堆,可理解為位於記憶體全域區。
  2. _NSConcreteStackBlock:具閉包行為(訪問外部變數),且因棧空間可重複使用,通常只執行一次,執行完即出棧,無法多次使用。
  3. _NSConcreteMallocBlock:具閉包行為,且需要多次執行,因而從棧複製到堆中以供重複調用。

3.3 編譯器如何編譯

以一段簡單示例說明:

#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 的資料結構定義,編譯器內部的運作便一目了然。

3.4 copy() 與 dispose()

若想在後續繼續使用某個 Block,就必須將它從棧空間複製到堆空間,這一過程需調用 Block_copy()。Block 的 descriptor 中有一個 copy() 輔助函數,會在 Block_copy() 中執行,當 Block 需要拷貝物件時,該函數會 retain 住已拷貝的物件。

與 Block_copy() 相對應的是 Block_release(),用於釋放不再需要的 Block。descriptor 中的 dispose() 輔助函數會在 Block_release() 中執行,負責與 copy() 相反的操作,例如釋放所有在 Block 中拷貝的變數。

四、實戰示例

4.1 參數為 NSString* 的 Block

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

4.2 用於字串陣列排序

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

4.3 Block 的遞歸調用

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

4.4 在 Block 中使用區域與全域變數

在 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

  1. 上一篇文章:
  2. 下一篇文章:
蘋果刷機越獄教程| IOS教程問題解答| IOS技巧綜合| IOS7技巧| IOS8教程
Copyright © IOS教程網 All Rights Reserved