《Objective-C高级编程》温故知新之"Blocks"

本文

前言

很久前看了《Objective-C高级编程 iOS与OS X多线程和内存管理》这本书,但当时看起来晦涩难懂。最近利用下班时间重读了一遍,觉得还是得记录一下。毕竟往后阶段对相同的东西会有更深刻的理解。温故知新! 系列文章: 1、《Objective-C高级编程》温故知新之"自动引用计数" 2、《Objective-C高级编程》温故知新之"Blocks"

Blocks概要

Blocks 是C语言的扩充功能,即带有自动变量(局部变量)的匿名函数。

在计算机科学中,此概念也称为闭包(Closure)、lambda计算等。Swift中称作闭包

其他程序语言中 Block 的名称

浅显理解 Block

1、Block 语法

完整形式的 Block 语法与一般的C语言函数定义相比,仅有两点不同。

(1)没有函数名。 (2)带有“^”。

上面第一点也是匿名函数的由来。

Block 语法如下:

注意:Block 语法可以省略好几个项目。

1、返回值类型

省略返回值类型,如果表达式有 return 语句就使用该返回值的类型,如果表达式中没有 return 语句就使用 void 类型。 表达式中含有多个 return 语句时,所有 return 的返回值类型必须相同。相当于

省略返回值类型

2、如果没有参数,参数列表也可以省略。

省略参数列表

2、截获自动变量值

了解了匿名函数,接下来得了解“带有自动变量值得匿名函数”中的“带有自动变量值”的含义。

 int dmy = 256;
    int val = 10;
    const char *fmt = "val = %d\n";
    void (^blk)(void) = ^{
        printf(fmt, val);
    };
        val = 2;
        fmt = "These values were changed. val = %d\n";
    blk();

打印:

val = 10

在调用blk前,改动了val,大家可能认为打印 val = 2,但实际上打印 val = 10;

该源码中,Block 语法表达式使用的是它之前声明的自动变量值为10的 val ,Block 表达式截获了这个值,并且保存下来,所以在执行 Block 语法后,即使在后面改写 Block 中使用的自动变量的值也不会影响 Block 执行时自动变量的值。

3、 __block 说明符

如果我们尝试修改截获的自动变量值,会怎么样,结果是会报错。 编译的时报“Variable is not assignable (missing __block type specifier)”

所以若要在 Block 语法的表达式中将值赋给在 Block 语法外声明的自动变量,需要在该自动变量上附加 __block 说明符

    __block int val = 0;
    void (^blk)(void) = ^{
        val = 1;
    };
    blk();
    printf("val = %d\n", val);

打印:

val = 1

注意:使用截获的值不会有问题,只有赋值才回报错。

深入理解 Block

1、Block 的实现

通过上篇系列文章讲到的 clang -rewrite-objc 将下列 Block 语句 转换为可读源码

    void (^blk)(void) = ^{(printf("Block\n"));};
    blk();
    return 0;

我们先挑出部分可读源码: 显然,上面代码被转换成了下列源码

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
      printf("Block\n");
}

该函数的参数 __cself 相当于 C++ 实例方法中指向实例自身的变量this, 或是 Objective-C 实例方法中指向对象自身的变量 self ,即参数 __cself 为指向 Block值的变量。

继续看源码中的参数 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;
  }
};

由于转换后的源码中,也一并写入了其构造函数,所以看起来稍显复杂,如果除开该构造函数,__main_block_impl_0结构体会变得非常简单。

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
};

第一个成员变量是 impl,看下 __block_impl impl的声明

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

我们从其名称可以联想到某些标志、今后版本升级所需的区域以及函数指针。这些会在后面详细说明。第二个成员是 Desc 指针,以下为其__main_block_desc_0结构体的声明。

static struct __main_block_desc_0 {
  size_t reserved;
  size_t Block_size;
}

如同其名称所示,其结构为今后版本升级所需的区域和 Block 的大小。

我们再回头看下初始化含有这些结构体的 __main_block_impl_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;
  }

进行讲解前,我们先看看构造函数的调用

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

简化后为

__main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA);

第一个参数是由 Block 语法转换的 C 语言函数指针。第二个是参数是作为静态全局变量初始化的 __main_block_desc_0结构体实例指针。问我怎么知道,看下面源码啊:

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

由此可知,该源码使用 Block,即__main_block_impl_0结构体实例的大小,进行初始化。 下面看看栈上的 __main_block_impl_0 结构体实例是如何根据这些参数进行初始化的。如果展开结构体__main_block_impl_0中的__block_impl结构体,可记述为如下形式:

struct __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int flags=0) {
    void *isa;
    int Flags;
    int Reserved;
    void *FuncPtr;
   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 = 0;
    impl.FuncPtr = __main_block_func_0;
    Desc = &__main_block_desc_0_DATA;
  }

从而,__main_block_impl_0构造函数已经足够清晰,除了_NSConcreteStackBlock仍未讲解,先看blk()的源码

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

去掉转换部分为

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

这就是简单的使用函数指针调用函数。

那么一直没说的_NSConcreteStackBlock是什么呢?

首先,将 Block 指针赋给 Block 的结构体成员变量 isa .为了理解他,首先要理解 Objective-C 类和对象的实质。其实,所谓 Block 就是 Objective-C 对象。

id 这一变量类型用于存储 Objective-C 对象。在 Objective-C 源代码中,虽然可以像使用 void *类型那样随意使用 id, 但此 id 类型也能在 C 语言中声明。在 runtime.h 声明如下:

typedef struct objc_object {
        Class isa;
    } *id;

id 为 objc_object 结构体的指针类型。 然后再看下 Class

typedef struct objc_class *Class;

Class 为objc_class 结构体 的指针类型。objc_class 结构体声明如下:

    struct objc_class {
        Class isa;
    };

这与 objc_object 结构体相同,所以

@interface MyObject : NSObject
{
    int val0;
    int val1;
}

上面代码基于 object_object 结构体,该类的对象的结构体如下:

struct MyObject {
    Class isa;
    int val0;
    int val1;
};

可以看出,MyObject 类的实例变量 val0 和 val1 被声明为对象的结构体成员。 意味着,生成的各个对象,也就是“由该类生成的对象的各个结构体实例,通过成员变量 isa 保持该类的结构体实例指针”,如下图所示。

Objective-C 类与对象的实质

各类的结构体就是基于 objc_class 结构体的 class_t 结构体。class_t 结构体在 obj4 运行时库声明如下:

    struct class_t {
        struct class_t *isa;
        struct class_t *superclass;
        Cache cache;
        IMP *vtable;
        uintptr_t data_NEVER_USE;
    };

回到之前的 Block 结构体,得知 _NSConcreteStackBlock,相当于 class_t 结构体实例。在将 Block 作为 Objective-C 的对象处理时,关于该类的信息放置于 _NSConcreteStackBlock,信息包含成员变量、方法名称、方法的实现(即函数指针)、属性以及父类的指针。

到此,我们已经了解 Block 的实质,知道 Block 即为 Objective-C 的对象了。

2、截获自动变量值

C代码

    int dmy = 256;
    int val = 10;
    const char *fmt = "val = %d\n";
    void (^blk)(void) = ^{
        printf(fmt, val);
    };
        val = 2;
        fmt = "These values were changed. val = %d\n";
    blk();

源代码

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;
  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; // bound by copy
  int val = __cself->val; // bound by copy

     z   printf(fmt, val);
    }

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[]) {

    int dmy = 256;
    int val = 10;
    const char *fmt = "val = %d\n";
    void (*blk)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, fmt, val));
        val = 2;
        fmt = "These values were changed. val = %d\n";
    ((void (*)(__block_impl *))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk);
    return 0;


}

我们挑出部分代码

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  const char *fmt;
  int val;
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  const char *fmt = __cself->fmt; // bound by copy
  int val = __cself->val; // bound by copy

     z   printf(fmt, val);
    }

从clang 编译后自带的注释得知是值复制,不是指针复制,不会受外界影响。再加上形参 __cself 是 block 自身,也就是说, val 值是执行block 内部语句时的值,也就是 10,这就是所谓的截获自动变量值原理。

3、__block 说明符

上面说到,添加__block 说明符则可以在 Block 内部修改截获的值,那原理是怎样的呢

C++代码

struct __Block_byref_val_0 {
  void *__isa;
__Block_byref_val_0 *__forwarding;
 int __flags;
 int __size;
 int val;
};

发现添加了__block 说明符,它竟然变成了结构体实例,结构体最后一个成员变量 val 相当于原自动变量。

4、Block 存储域

Block 语法根据不同类型变量(下图的类是转换过后的类),存储的位置也不同。如下图:

Block 的类

1、_NSConcreteStackBlock

截获自动变量,上面讲得 Block 类都是 _NSConcreteStackBlock 类,存储在栈上。

2、_NSConcreteGlobalBlock

记述全局变量的地方使用 Block 语法时,生成的就是该类。存储在数据区域。 例如下列代码:

void (^blk)(void) = ^{ //此时将 Block 用结构体实例设置在程序的数据区域。
    printf("Global Block\n");
};
int main(int argc, const char * argv[]) { ... }

3、_NSConcreteMallocBlock

在某种情况下,Block 会被复制到堆上,即存储在堆上。 例如下列代码:

/**对于引用了外部变量的Block,如果没有对他进行copy,*/
/**他的作用域只会在声明他的函数栈内(类型是__NSStackBlock__),*/
/**如果想在非ARC下直接返回此类Block,Xcode会提示编译错误的 */

  typedef int(^MyBlock)();

        MyBlock func()
        {
             //ARC
             int i = 1;
             return ^{ return i; };   
        }

/** ----------------------- */
  typedef int(^MyBlock)();

        MyBlock func()
        {
             //非ARC
             int i = 1;
             return [^{ return i; } copy];   在这里修改一下就好了
        }

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏维C果糖

编程思想 之「对象漫谈」

在「语言导论」中,我们曾提到过「万物皆对象」,事实上,也确实如此。在面向对象编程的世界中,我们创建对象、操作对象、销毁对象,我们所做的一切动作都离不开对象。在本...

55819
来自专栏Web 开发

JavaScript的对象引用

在一个函数体内,var变量声明的变量,其作用域只在该函数体内,对于函数体外而言,是不可见的(废话)。

840
来自专栏xx_Cc的学习总结专栏

iOS底层原理总结 - 探寻block的本质(二)

3014
来自专栏逸鹏说道

Python3 与 C# 基础语法对比(List、Tuple、Dict专栏)

Python3 与 C# 基础语法对比(基础知识场):https://www.cnblogs.com/dotnetcrazy/p/9102030.html

24710
来自专栏闵开慧

java概念1

public static void main(String[] args) {//其中[]也可以写在args后面,args也可以随便写成其他字母,例如asd...

36111
来自专栏ShaoYL

OC语言Block 续

1389
来自专栏屈定‘s Blog

Java--Enum的思考

枚举类是Java5引进的特性,其目的是替换int枚举模式或者String枚举模式,使得语义更加清晰,另外也解决了行为和枚举绑定的问题.

1434
来自专栏IT派

一文读懂Python中的异常处理

异常处理在任何一门编程语言里都是值得关注的一个话题,良好的异常处理可以让你的程序更加健壮,清晰的错误信息更能帮助你快速修复问题。在Python中,和不部分高级语...

1340
来自专栏前端进阶之路

JavaScript数据结构03 - 队列

队列是遵循FIFO(First In First Out,先进先出)原则的一组有序的项。队列在尾部添加新元素,并从顶部移除元素。最新添加的元素必须排在队列的末尾...

1011
来自专栏liulun

Nim教程【十四】

网友@沉没捕鱼,赞助了一台服务器 这个系列的教程写完之后,我们就要开始着手搭建Nim的社区了~ 异常 Nim中的异常类型是对象类型 根据惯例,Nim中的异常类型...

2416

扫码关注云+社区

领取腾讯云代金券