小杰后车座抱着妈妈去姥姥家搬家,亚洲国产综合精品一区,女性一晚上3次纵欲导致不孕

老生常談之Block

前面有一篇介紹Block的博客，主要介紹了Block的簡單使用技巧。這篇博客主要更加深入地了解一下Block。包括：Block的實現、__Block的原理以及Block的存儲域三方面。

Block的實現

首先我們使用Xcode創建一個Project,點擊File-->New-->Project，選擇macOS中Application的Command Line Tool，然后設置Project Name即可。你好發現這個工程值包含了一個main.m文件，然后我們做如下更改（更改后的代碼如下）：

#import <stdio.h>

int main(int argc, const char * argv[]) {
    printf("Hello World");
    return 0;
}

這個是我們最常見的C代碼，導入stdio.h，然后打印出來Hello World。接下來我們寫一個最簡單的block，沒有返回值，沒有傳入參數：

#import <stdio.h>

int main(int argc, const char * argv[]) {
    
    void (^blk)(void) = ^{
        printf("Hello Worldddd");
    };
    blk();
    return 0;
}

打印出來的結果相當于調用了blk輸出的結果。接下來我們在item中跳轉到main.m所在文件夾然后執行如下命令：

clang -rewrite-objc main.m

你會發現在當前文件夾下生成了一個.cpp文件，它是經過clang編譯器編譯之后的文件，打開之后里面大概有5百多行，其實我們看下面的這些代碼就足夠了：

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;
  }
};
#ifndef BLOCK_IMPL
#define BLOCK_IMPL
struct __block_impl {
    void *isa;
    int Flags;
    int Reserved;
    void *FuncPtr;
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {

        printf("Hello Worldddd");
    }

static struct __main_block_desc_0 {
  size_t reserved;
  size_t Block_size;
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0)};
int main(int argc, const char * argv[]) {

    void (*blk)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA));
    ((void (*)(__block_impl *))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk);
    return 0;
}

其中包含三個結構體：

__main_block_impl_0、__block_impl、__main_block_desc_0

和兩個方法：

__main_block_func_0、main

main就是我們寫的main函數。
至此，你能知道的就是：Block看上去很特別，其實就是作為及其普通的C語言源代碼來處理的。編譯器會把Block的源代碼轉換成一般的C語言編譯器能處理的源代碼，并作為極為普通的C語言源代碼被編譯。
接下來對編譯的內容來一個分解，首先是

^{printf("Hello Worldddd")};

變換后的源代碼如下：

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {

        printf("Hello Worldddd");
    }

也就是現在變成了一個靜態方法，其命名方式為：Block所屬的函數名(main)和該Block語法在函數出現的順序值(0)來給經過clang變換的函數命名。該方法的參數相當于我們在OC里面的指向自身的self。我們看一下該參數的聲明：

struct __main_block_impl_0 *__cself

你會發現它其實是一個結構體，該結構體的聲明如下：

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;
  }
};

該結構體中你會發現里面有一個構造函數，你忽略構造函數，會發現該結構體就很簡單了，只是包含了impl和 Desc兩個屬性變量。其中impl也是一個結構體，它的結構如下：

struct __block_impl {
    void *isa;
    int Flags;
    int Reserved;
    void *FuncPtr;
};

從屬性變量的名字我們可以猜測出該結構體各個屬性的含義：

isa：isa指針，指向父類的指針。
Flags：一個標記
Reserved：預留區域，用于以后的使用。
FuncPtr：這個很重要，是一個函數指針。后面會詳細說明它的作用。

第二個變量是Desc，也是一個結構體：

static struct __main_block_desc_0 {
  size_t reserved;
  size_t Block_size;
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0)};

這個結構體就比較簡單了，一個預留位，一個是指代該Block大小的屬性，后面又包含了一個該實例：

__main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0)};

預留位為0，大小為傳入結構體的大小。接下來就是很重要的構造函數了：

 __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;
  }

其中的&_NSConcreteStackBlock用于初始化impl的isa指針；flags為0；FuncPtr是構造函數傳過來的fp函數指針；Desc為一個block的描述。到這里三個結構體和一個函數就介紹完了。接下來看一下main函數里面上述構造函數是如何調用的：

 void (*blk)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA));

感覺好復雜，我們先做一個轉換：

struct __main_block_impl_0 tmpeImpl = __main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA)

struct __main_block_impl_0 *blk = &tmpeImpl;

也就是說把結構體的實例的指針賦值給blk。接下來再看一下構造函數的的初始化，其實賦值就變成了這樣：

impl.isa = &_NSConcreteStackBLock;
impl.Flags = 0;
impl.FuncPtr = __main_block_func_0;
Desc = &__main_block_desc_0_DATA;

現在在看一下調用block的那句代碼：

blk();

轉換成了：

((void (*)(__block_impl *))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk);

這個轉換不是太明白，但是知道他的作用就是把blk當做參數傳進去，調用的FuncPtr所指向的函數，也就是__ block _ block _ func _ 0。

到這里就大體了解了Block的實現，其實就是C的幾個結構體和方法，經過賦值和調用，進而實現了Block。
另外Block其實實質上也是OC的對象。

__Block的原理

先看一個簡單的例子：

#import <stdio.h>

int main(int argc, const char * argv[]) {
    int i = 3;
    void (^blk)(void) = ^{
        printf("Hello World,%d",i);
    };
    blk();
    return 0;
}

使用clang編譯后是這樣的：


struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  int i;
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _i, int flags=0) : i(_i) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  int i = __cself->i; // bound by copy

        printf("Hello World,%d",i);
    }

int main(int argc, const char * argv[]) {
    int i = 3;
    void (*blk)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, i));
    ((void (*)(__block_impl *))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk);
    return 0;
}

也就是在main函數調用的時候把i傳到了構造函數里，然后通過i(_i)對結構體的屬性變量i賦值，i變量現在已經成為了結構體的一個樹形變量。在構造函數執行時把i賦值。在 __ main _ block_func _ 0里面通過 __ cself調用，這個變量實際是在聲明block時，被復制到了結構體變量i，因此不會影響變量i的值。當我們嘗試在Block中去修改時，你會得到如下錯誤：

Variable is not assignable(missing __block type specifier)

提示我們加上__block,接下來我們將源代碼做如下修改：

int main(int argc, const char * argv[]) {
    __block int i = 3;
    void (^blk)(void) = ^{
        i = i + 3;
        printf("Hello World,%d",i);
    };
    blk();
    return 0;
}

運行一下你會發現你成功對i的值進行了修改！用clang進行編譯，結果如下:

struct __Block_byref_i_0 {
  void *__isa;
__Block_byref_i_0 *__forwarding;
 int __flags;
 int __size;
 int i;
};

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  __Block_byref_i_0 *i; // by ref
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_i_0 *_i, int flags=0) : i(_i->__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_i_0 *i = __cself->i; // bound by ref

        (i->__forwarding->i) = (i->__forwarding->i) + 3;
        printf("Hello World,%d",(i->__forwarding->i));
    }
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {_Block_object_assign((void*)&dst->i, (void*)src->i, 8/*BLOCK_FIELD_IS_BYREF*/);}

static void __main_block_dispose_0(struct __main_block_impl_0*src) {_Block_object_dispose((void*)src->i, 8/*BLOCK_FIELD_IS_BYREF*/);}

static struct __main_block_desc_0 {
  size_t reserved;
  size_t 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(int argc, const char * argv[]) {
    __attribute__((__blocks__(byref))) __Block_byref_i_0 i = {(void*)0,(__Block_byref_i_0 *)&i, 0, sizeof(__Block_byref_i_0), 3};
    void (*blk)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_i_0 *)&i, 570425344));
    ((void (*)(__block_impl *))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk);
    return 0;
}

你會發現多了一個__ Block _ byref _i _ 0的結構體，然后多了兩個copy和dispose函數。
看一下main函數里面的i，此時也不再是一個簡單的基本類型int，而是一個初始化的 __ Block _ byref _ i _ 0的結構體，該結構體有個屬性變量為i，然后把3賦值給了那個屬性變量。該結構體還有一個指向自己的指針 __ forwarding，它被賦值為i的地址。
現在 __ main _ block _ func _ 0在實現中使用了指向該變量的指針，所以達到了修改外部變量的作用。

Block的存儲域

Block的存儲域有以下幾種：

_ NSConcreteStackBlock,該類的對象Block設置在棧上
_ NSConcreteGlobalBlock,該類的Block設置在程序的數據區(.data)域中。
_ NSConcreteMallocBlcok,該類的Block設置在堆上
下面這張圖展示了Block的存儲域:

Block的存儲域

我們前面看到的都是在Stack的Block，但是你可以在OC工程中打印一下你聲明的block的isa，你會發現它其實是Malloc的block，也就是在堆上的block。如圖：

堆上的block

還有一種情況是Global的block：

global的block

在ARC中，只有NSConcreteGlobalBlock和NSConcreteMallockBlock兩種類型的block。因為我們最簡單的block在工程中打印出來的都是MallocBlock。也許是因為蘋果把對象都放到了堆管理，而Block也是對象，所以也放到了堆上。

此時我們也許會有個疑問：Block超出了變量作用域為什么還能存在呢？
對于Global的Block，變量作用域之外也可以通過指針安全使用，但是設置在棧上的就比較尷尬了，作用域結束后，Block也會被廢棄。為了使Block超出變量作用域還可以存在，Block提供了將Block和 __ block變量從棧上復制到堆上的方法來解決這個問題。這樣就算棧上的廢棄，堆上的Block還可以繼續存在。

看一下對Block進行復制，結果如何：

Block進行copy操作

如果對Block進行了copy操作，__ block的變量也會受到影響，當 __ block的變量配置在棧上，復制之后它將從棧復制到堆上并被Blcok持有，如果是堆上的 __ block變量，Blcok復制之后該變量被Block持有。
如果兩個block（block1,block2）同時都是用 __ block變量，如果block1被復制到了堆上，那么 __ block變量也會在block1復制到堆的同時復制到堆上，當block2再是用到 __ block變量的時候，只是增加堆上 __ block變量的引用計數，不會再次復制。如果堆上的block1和block2被廢棄了，那么它所是用的 __ block變量也就被釋放了（如果block1被廢棄，而block2沒有被廢棄，那么 __ block變量的引用計數-1，直到最后使用 __ block變量的block被廢棄的同時，堆上的 __ block也會被釋放）。
理解了上面剛才說的復制之后，現在回過來思考另一個問題： __ block的時候轉換的結構體中的 __ forwarding指針有什么作用呢？（下面代碼中的 __ forwarding）

struct __Block_byref_i_0 {
  void *__isa;
__Block_byref_i_0 *__forwarding;
 int __flags;
 int __size;
 int i;
};

其實是這樣的：棧上的 __ block變量用結構體實例在 __ block變量從棧復制到堆上的時候，會將成員變量 __ forwarding的值替換為復制目標堆上的 __ block變量用結構體實例的地址。通過該操作之后，無論是在Block語法中、Block語法外使用 __ block變量，還是 __ block變量配置在棧上或者堆上，都可以順利地訪問同一個 __ block變量。

以上便是對block的進一步介紹，主要參考了《Objective-C高級編程 iOS與OS X多線程和內存管理》一書。

轉贊請注明來源：http://www.lxweimin.com/p/c7c8ad987e5e

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美 国产 综合 欧美 视频

老生常談之Block

老生常談之Block

Block的實現

__Block的原理

Block的存儲域

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频