全面解析Objective-C中的block代码块的使用

末蓝、 2022-07-20 15:05 154阅读 0赞

**1.1 操作系统中的栈和堆**

注：这里所说的堆和栈与数据结构中的堆和栈不是一回事。

我们先来看看一个由C/C++/OBJC编译的程序占用内存分布的结构：

![201511492644909.jpg (844×367)][201511492644909.jpg _844_367]

栈区（stack）：由系统自动分配，一般存放函数参数值、局部变量的值等。由编译器自动创建与释放。其操作方式类似于数据结构中的栈，即后进先出、先进后出的原则。

例如：在函数中申明一个局部变量int b;系统自动在栈中为b开辟空间。

堆区（heap）：一般由程序员申请并指明大小，最终也由程序员释放。如果程序员不释放，程序结束时可能会由OS回收。对于堆区的管理是采用链表式管理的，操作系统有一个记录空闲内存地址的链表，当接收到程序分配内存的申请时，操作系统就会遍历该链表，遍历到一个记录的内存地址大于申请内存的链表节点，并将该节点从该链表中删除，然后将该节点记录的内存地址分配给程序。

例如：在C中malloc函数

复制代码代码如下:

char p1;   
p1 = (char )malloc(10);

但是p1本身是在栈中的。

链表：是一种常见的基础数据结构，一般分为单向链表、双向链表、循环链表。以下为单向链表的结构图：

![201511492710858.jpg (428×73)][201511492710858.jpg _428_73]

单向链表是链表中最简单的一种，它包含两个区域，一个信息域和一个指针域。信息域保存或显示关于节点的信息，指针域储存下一个节点的地址。

上述的空闲内存地址链表的信息域保存的就是空闲内存的地址。

全局区/静态区：顾名思义，全局变量和静态变量存储在这个区域。只不过初始化的全局变量和静态变量存储在一块，未初始化的全局变量和静态变量存储在一块。程序结束后由系统释放。

文字常量区：这个区域主要存储字符串常量。程序结束后由系统释放。

程序代码区：这个区域主要存放函数体的二进制代码。

下面举一个前辈写的例子：

复制代码代码如下:

//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"); // 123456\\0在常量区，这个函数的作用是将"123456" 这串字符串复制一份放在p1申请的10个字节的堆区域中。  
    // p3指向的"123456"与这里的"123456"可能会被编译器优化成一个地址。  
\}

strcpy函数

原型声明：extern char \*strcpy(char\* dest, const char \*src);

功能：把从src地址开始且含有NULL结束符的字符串复制到以dest开始的地址空间。

**1.2 结构体（Struct）**

在C语言中，结构体(struct)指的是一种数据结构。结构体可以被声明为变量、指针或数组等，用以实现较复杂的数据结构。结构体同时也是一些元素的集合，这些元素称为结构体的成员(member)，且这些成员可以为不同的类型，成员一般用名字访问。

我们来看看结构体的定义：

复制代码代码如下:

struct tag \{ member-list \} variable-list;

*  struct：结构体关键字。
 *  tag：结构体标签。
 *  member-list：结构体成员列表。
 *  variable-list：为结构体声明的变量列表。

在一般情况下，tag，member-list，variable-list这三部分至少要出现两个。以下为示例：

复制代码代码如下:

// 该结构体拥有3个成员，整型的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;

以上就是简单结构体的代码示例。结构体的成员可以包含其他结构体，也可以包含指向自己结构体类型的指针。结构体的变量也可以是指针。

下面我们来看看结构体成员的访问。结构体成员依据结构体变量类型的不同，一般有2种访问方式，一种为直接访问，一种为间接访问。直接访问应用于普通的结构体变量，间接访问应用于指向结构体变量的指针。直接访问使用结构体变量名.成员名，间接访问使用(\*结构体指针名).成员名或者使用结构体指针名->成员名。相同的成员名称依靠不同的变量前缀区分。

复制代码代码如下:

struct EXAMPLE\{  
    int a;  
    char b;  
\};  
//声明结构体变量s1和指向结构体变量的指针s2  
struct EXAMPLE s1, \*s2;  
//给变量s1和s2的成员赋值,注意s1.a和s2->a并不是同一成员  
s1.a = 5;  
s1.b = 6;  
s2->a = 3;  
s2->b = 4;

最后我们来看看结构体成员存储。在内存中，编译器按照成员列表顺序分别为每个结构体成员分配内存。如果想确认结构体占多少存储空间，则使用关键字sizeof，如果想得知结构体的某个特定成员在结构体的位置，则使用offsetof宏(定义于stddef.h)。

复制代码代码如下:

struct EXAMPLE\{  
    int a;  
    char b;  
\};  
//获得EXAMPLE类型结构体所占内存大小  
int size\_example = sizeof( struct EXAMPLE );  
//获得成员b相对于EXAMPLE储存地址的偏移量  
int offset\_b = offsetof( struct EXAMPLE, b );

**1.3 闭包（Closure）**

闭包就是一个函数，或者一个指向函数的指针，加上这个函数执行的非局部变量。

说的通俗一点，就是闭包允许一个函数访问声明该函数运行上下文中的变量，甚至可以访问不同运行上文中的变量。

我们用脚本语言来看一下：

复制代码代码如下:

通过上面的代码我们可以看出，按常规思维来说，变量str是函数funB的局部变量，作用域只在函数funB中，函数funA是无法访问到str的。但是上述代码示例中函数funA中的callback可以访问到str，这是为什么呢，因为闭包性。

**2.blcok基础知识**

block实际上就是Objective-C语言对闭包的实现。

**2.1 block的原型及定义**

我们来看看block的原型：

复制代码代码如下:

NSString \* ( ^ myBlock )( int );

上面的代码声明了一个block(^)原型，名字叫做myBlock，包含一个int型的参数，返回值为NSString类型的指针。

下面来看看block的定义：

复制代码代码如下:

myBlock = ^( int paramA )  
\{  
    return \[ NSString stringWithFormat: @"Passed number: %i", paramA \];  
\};

上面的代码中，将一个函数体赋值给了myBlock变量，其接收一个名为paramA的参数，返回一个NSString对象。

注意：一定不要忘记block后面的分号。

定义好block后，就可以像使用标准函数一样使用它了：

复制代码代码如下:

myBlock(7);

由于block数据类型的语法会降低整个代码的阅读性，所以常使用typedef来定义block类型。例如，下面的代码创建了GetPersonEducationInfo和GetPersonFamilyInfo两个新类型，这样我们就可以在下面的方法中使用更加有语义的数据类型。

复制代码代码如下:

// Person.h  
\#import // Define a new type for the block  
typedef NSString \* (^GetPersonEducationInfo)(NSString \*);  
typedef NSString \* (^GetPersonFamilyInfo)(NSString \*);  
@interface Person : NSObject  
\- (NSString \*)getPersonInfoWithEducation:(GetPersonEducationInfo)educationInfo  
    andFamily:(GetPersonFamilyInfo)familyInfo;  
@end

我们用一张大师文章里的图来总结一下block的结构：

![201511492752307.png (1140×420)][201511492752307.png _1140_420]

**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 闭包性**

上文说过，block实际是Objc对闭包的实现。

我们来看看下面代码：

复制代码代码如下:

\#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函数中声明了一个整型，并赋值42，另外还声明了一个block，该block会将42返回。然后将block传递给logBlock函数，该函数会显示出返回的值42。即使是在函数logBlock中执行block，而block又声明在main函数中，但是block仍然可以访问到x变量，并将这个值返回。

注意：block同样可以访问全局变量，即使是static。

**2.4 block中变量的复制与修改**

对于block外的变量引用，block默认是将其复制到其数据结构中来实现访问的，如下图：

![201511492912717.jpg (319×162)][201511492912717.jpg _319_162]

通过block进行闭包的变量是const的。也就是说不能在block中直接修改这些变量。来看看当block试着增加x的值时，会发生什么：

复制代码代码如下:

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

编译器会报错，表明在block中变量x是只读的。

有时候确实需要在block中处理变量，怎么办？别着急，我们可以用\_\_block关键字来声明变量，这样就可以在block中修改变量了。

基于之前的代码，给x变量添加\_\_block关键字，如下：

复制代码代码如下:

\_\_block int x;

对于用\_\_block修饰的外部变量引用，block是复制其引用地址来实现访问的，如下图：

![201511492939578.jpg (252×143)][201511492939578.jpg _252_143]

**3.编译器中的block**

**3.1 block的数据结构定义**

我们通过大师文章中的一张图来说明：

![201511493000042.jpg (510×511)][201511493000042.jpg _510_511]

上图这个结构是在栈中的结构，我们来看看对应的结构体定义：

复制代码代码如下:

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类型、判断block引用计数、判断block是否需要执行辅助函数等。

reserved：保留变量，我的理解是表示block内部的变量数。

invoke：函数指针，指向具体的block实现的函数调用地址。

descriptor：block的附加描述信息，比如保留变量数、block的大小、进行copy或dispose的辅助函数指针。

variables：因为block有闭包性，所以可以访问block外部的局部变量。这些variables就是复制到结构体中的外部局部变量或变量的地址。

**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类型的block从栈中复制到堆中形成的。例如下面代码中，在exampleB\_addBlockToArray方法中的block还是\_NSConcreteStackBlock类型的，在exampleB方法中就被复制到了堆中，成为\_NSConcreteMallocBlock类型的block：

复制代码代码如下:

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要么是空block，要么是不访问任何外部变量的block。它既不在栈中，也不在堆中，我理解为它可能在内存的全局区。
2.  \_NSConcreteStackBlock类型的block有闭包行为，也就是有访问外部变量，并且该block只且只有有一次执行，因为栈中的空间是可重复使用的，所以当栈中的block执行一次之后就被清除出栈了，所以无法多次使用。
3.  \_NSConcreteMallocBlock类型的block有闭包行为，并且该block需要被多次执行。当需要多次执行时，就会把该block从栈中复制到堆中，供以多次执行。

**3.3 编译器如何编译**

我们通过一个简单的示例来说明：

复制代码代码如下:

\#import typedef void(^BlockA)(void);  
\_\_attribute\_\_((noinline))  
void runBlockA(BlockA block) \{  
    block();  
\}  
void doBlockA() \{  
    BlockA block = ^\{  
        // Empty block  
    \};  
    runBlockA(block);  
\}

上面的代码定义了一个名为BlockA的block类型，该block在函数doBlockA中实现，并将其作为函数runBlockA的参数，最后在函数doBlockA中调用函数runBloackA。

注意：如果block的创建和调用都在一个函数里面，那么优化器(optimiser)可能会对代码做优化处理，从而导致我们看不到编译器中的一些操作，所以用\_\_attribute\_\_((noinline))给函数runBlockA添加noinline，这样优化器就不会在doBlockA函数中对runBlockA的调用做内联优化处理。

我们来看看编译器做的工作内容：

复制代码代码如下:

\#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的数据结构定义，我们能很容易得理解编译器内部对block的工作内容。

**3.4 copy()和dispose()**

上文中提到，如果我们想要在以后继续使用某个block，就必须要对该block进行拷贝操作，即从栈空间复制到堆空间。所以拷贝操作就需要调用Block\_copy()函数，block的descriptor中有一个copy()辅助函数，该函数在Block\_copy()中执行，用于当block需要拷贝对象的时候，拷贝辅助函数会retain住已经拷贝的对象。

既然有有copy那么就应该有release，与Block\_copy()对应的函数是Block\_release()，它的作用不言而喻，就是释放我们不需要再使用的block，block的descriptor中有一个dispose()辅助函数，该函数在Block\_release()中执行，负责做和copy()辅助函数相反的操作，例如释放掉所有在block中拷贝的变量等。

**4.下面来看几个具体的运行示例：  
4.1参数是NSString\*的代码块**

复制代码代码如下:

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\];  
        NSLog(@"sortArray:%@", sortArray);

运行结果：

sortArray:(
      "abc 05",
      "abc 1",
      "abc 12",
      "abc 13",
      "abc 21"
    )

**4.3代码块的递归调用**  
代码块想要递归调用，代码块变量必须是全局变量或者是静态变量，这样在程序启动的时候代码块变量就初始化了，可以递归调用

复制代码代码如下:

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在代码块中使用局部变量和全局变量**  
在代码块中可以使用和改变全局变量

复制代码代码如下:

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

而局部变量可以使用，但是不能改变。

复制代码代码如下:

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
         local:501

**Tags：** [Objective-C][]  [block][]

[201511492644909.jpg _844_367]: /images/20220720/a062f1426248441990afb0d87a6e1fcb.png
[201511492710858.jpg _428_73]: /images/20220720/b5a58e55ffa44ca7925f9c01fe462cd1.png
[201511492752307.png _1140_420]: /images/20220720/eee67235a73246c0aa0a654c22234e72.png
[201511492912717.jpg _319_162]: /images/20220720/28896acdee6f43e2978f3fdd60e5ec74.png
[201511492939578.jpg _252_143]: /images/20220720/981cd5ef955e4f7aacd9e51b9ef69412.png
[201511493000042.jpg _510_511]: /images/20220720/362286d6acff4157a12dca347a1486e6.png
[Objective-C]: http://img.jb51.net/tag/Objective-C/1.htm
[block]: http://img.jb51.net/tag/block/1.htm