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

Blocks 的底層實現:Block 其實就是 Objective-C 物件

編輯:iOS 開發綜合

上一回我們談了 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 成員的。

main 中的構造函式呼叫

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;

呼叫 blk()

((void (*)(struct __block_impl *))((struct __block_impl *)blk)->FuncPtr)((struct __block_impl *)blk);
// 去掉轉型後
(*blk->impl.FuncPtr)(blk);

這就是最單純的函式指標呼叫。__cself 指向 Block 值,也就是把 Block 本身當成參數傳進去。

Block 就是 Objective-C 物件

關鍵在 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;
}

重點有兩個:

  • Block 表達式中使用的自動變數,會被追加成 __main_block_impl_0 的成員變數(此例是 val 與 fmt)。未被使用的自動變數不會被追加,截獲只針對 Block 中實際用到的變數。
  • 構造函式在初始化結構體實例時,會用執行 Block 語法當時的自動變數值來初始化這些成員。

因此 Block 表達式中的 printf(fmt, val) 完全不需要改寫,就能讀到被截獲下來的值。這就是「保存執行 Block 語法瞬間的自動變數值」的實作方式。

最後補充一點:Block 不能直接使用 C 陣列型別。因為在構造函式中把陣列參數賦值給成員變數這件事本身,在 C 語言裡就不合法(陣列不能指派),所以 Block 也無法截獲 C 陣列。

__block 說明符的實現

前面提到,在 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 說明符

__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 從堆疊複製到堆上時的所有權搬移,這個議題值得再單獨用一篇來說明。

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