Objective-C中Block精解

C语言函数指针

int func(int count)
正常调用:int result = func(10)
函数指针调用:

1
2
int (*funcPtr)(int) = &func;
int result = (*funcPtr)(10);

看到这里是不是觉得函数指针调用有点像Block的味道了

typedef给类型取一个别名

typedef int (^blk)(int)
给这个block类型取一个blk的名称

Block的实质

其实就是结构体__main_block_impl_0指针

1
void (^blk)(void) = ^{printf("Block");};

Block结构体

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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;
     }
}

注意这里也有个isa指针，我们知道OC的对象也有isa指针，说明Block其实也是一个对象

1
2
3
4
5
{printf("Block");};
实际上是下面这个函数
static void __main_block_func_0(struct __main_block_impl_0 *__cself){
    printf("Block");
}

Block类型变量

1
blk= &__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA);
1
2
3
4
5
static struct __main_block_desc_0  __main_block_desc_0_DATA = {
      0,
      sizeof(struct __main_block_impl_0)
};
__main_block_desc_0_DATA即是结构体实例__main_block_impl_0的大小

Block的调用实质就是调用这个结构体指针所指向的函数blk();

1
（*blk->impl.FuncPtr）(blk)

截获变量

自动变量（局部变量）【在block函数中不能改变其值】

被截获的自动变量被保存到__main_block_impl_0结构体中，作为它的成员变量，如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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, int flags=0){
              impl.isa = &_NSConcreteStackBlock;
              impl.Flags = flags;
              impl.FuncPtr = fp;
              Desc = desc;
              //截获的值在这里初始化
              fmt = "block";
              val = 10;
     }
}

block函数转换为以下函数：

1
{printf(fmt, val);};

实际上是一个函数

1
2
3
4
5
static void __main_block_func_0(struct __main_block_impl_0 *__cself){
    const char *fmt = __cself->fmt;
    int val = __cself->val;
    printf(fmt, val);
}

静态变量【由于截获的是该变量的地址，所以在block函数中可以做任何操作】

与自动变量不同，被截获的静态变量的地址被保存到__main_block_impl_0结构体中，作为它的成员变量，如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
static int static_val = 3;
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 flags=0, int *static_val){
              impl.isa = &_NSConcreteStackBlock;
              impl.Flags = flags;
              impl.FuncPtr = fp;
              Desc = desc;
              //截获的值在这里初始化
              static_val = static_val;
     }
}

block函数转换为以下函数：

1
2
static int static_val = 3;
{ static_val = 10;};

实际上是一个函数

1
2
3
4
static void __main_block_func_0(struct __main_block_impl_0 *__cself){
    int *static_val = __cself->static_val;
    *static_val = 10;
}

静态全局变量

变量存储在全局区，不归block管不会被保存到block结构体中。在block函数中做任何操作都行

全局变量

变量存储在全局区，不归block管不会被保存到block结构体中。在block函数中做任何操作都行

截获对象

截获对象时Block结构体会多出一个__strong修饰符的对象如：

1
2
3
4
5
6
7
8
9
10
11
12
struct __main_block_impl_0 {
   struct __block_impl impl;
   struct __main_block_desc_0 *Desc;
   id __strong array;//被截获的对象
   //结构体初始化
      __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, id __strong _array,int flags=0,){
              impl.isa = &_NSConcreteStackBlock;
              impl.Flags = flags;
              impl.FuncPtr = fp;
              Desc = desc;
     }
}

此外还会多两个函数：
当Block从栈复制到堆时调用

1
static void __main_block_func_0(struct __main_block_impl_0 *__cself, id obj);

当Block废弃时调用

1
static void __main_block_dispose_0(struct __main_block_impl_0 *src);

__block说明符

自动变量在block函数中是不能改变其值的，那如果要改变其值该怎么办？
在变量前加个__block修饰符就行了
__block类似于static，用于指定该变量设置到哪个存储域中，如：

1
__block int val = 10;

那么加了__block修饰符的自动变量将转换为一个结构体：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
__Block_byref_val_0 val = {
      0,
      &val,
      0,
      sizeof(__Block_byref_val_0),
      10
}
struct __Block_byref_val_0 {
      void *__isa;
      __Block_byref_val_0 *__forwarding;//指向结构体自身的指针
      int flags;
      int __size;
      int val;//变量的值
};

这样一来就跟静态变量一样，只要把__Block_byref_val_0的地址保存到__main_block_impl_0结构体中，作为它的成员变量，如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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, int flags=0, __Block_byref_val_0 *val){
              impl.isa = &_NSConcreteStackBlock;
              impl.Flags = flags;
              impl.FuncPtr = fp;
              Desc = desc;
              //截获的值在这里初始化
              val = val;
     }
}

block函数转换为以下函数：

1
2
__block int val = 10;
{ val = 10;};

实际上是一个函数

1
2
3
4
static void __main_block_func_0(struct __main_block_impl_0 *__cself){
    __Block_byref_val_0 *val = __cself->val;
    val ->__forwarding->val = 10;
}

Block存储域

__NSConcreteGlobalBlock

全局block，存放在data区，以下为全局block：

  1. 记述全局变量的地方有Block语法时
  2. Block语法的表达式中不使用应截获的自动变量时

    __NSConcreteStackBlock

    栈block，存放在栈区，作用域结束时，系统自动回收，除了以上全局变量的情况之外，其余的block都是栈block

    __NSConcreteMallocBlock

    堆block，存放在堆区，由程序猿手动释放内存。这是为了解决block夸作用域使用，将栈中的block拷贝到堆上，大部分情况，编译器会自动拷贝。有时也要自己手动拷贝

    什么情况下Block会从栈复制到堆

  • 调用Block的copy方法
  • Block作为函数返回值返回时
  • 将Block赋值给附有__strong修饰符id类型的类或Block类型成员变量时
  • 在方法名中含有usingBlock的cocoa框架方法或Grand Central Dispatch的API中传递Block时

    __block类型变量的存储域

    使用__block变量，当block从栈复制到堆时，__block变量也会一并复制到堆上，并被Block持有，当Block被废弃时__block变量也废弃
赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

不断超越自己