浅谈OC中Block的本质

时间  2021-08-14
标签 html c++ 程序员 bash 微信 markdown iphone 函数 oop spa 栏目 HTML 繁體版
原文   原文链接

Block简介

  • block是将函数及其执行上下文封装起来的一个对象
  • 在block实现的内部，有不少变量，由于block也是一个对象
  • 其中包含了诸如isa指针，imp指针等对象变量，还有储存其截获变量的对象等
  • 原文博客地址: 浅谈OC中Block的本质

定义和使用

block根据有无参数和有无返回值有如下几种简单使用方式html

// 无参数无返回值
void (^ BlockOne)(void) = ^(void){
    NSLog(@"无参数，无返回值");  
};  
BlockOne();//block的调用

// 有参数无返回值
void (^BlockTwo)(int a) = ^(int a){
    NSLog(@"有参数，无返回值, 参数 = %d，",a);
};  
BlockTwo(100);

// 有参数有返回值
int (^BlockThree)(int,int) = ^(int a,int b){    
    NSLog(@"有参数，有返回值");
    return a + b; 
};  
BlockThree(1, 5);

// 无参数有返回值
int(^BlockFour)(void) = ^{
    NSLog(@"无参数，有返回值");
    return 100;
};
BlockFour();
复制代码

但是以上四种block底层又是如何实现的呢? 其本质到底如何? 接下来咱们一块儿探讨一下c++

Block的本质

  • 为了方便咱们这里新建一个Command Line Tool项目, 在main函数中执行上述中一个block
  • 探索Block的本质, 就要查看其源码, 这里咱们使用下面命令把main.m文件生成与其对应的c++代码文件
  • 在main.m文件所在的目录下, 执行以下命令, 会生成一个main.cpp文件
  • 把main.cpp文件添加到项目中, 并使其不参与项目的编译, 下面咱们就具体看一下block的底层究竟是如何实现的
xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc main.m
复制代码

打开main.cpp文件, 找到文件最底部, 能够看到block的相关源码以下程序员

// block的结构体
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;
  }
};

// 封装了block执行逻辑的函数
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {

            NSLog((NSString *)&__NSConstantStringImpl__var_folders_ty_804897ld2zg4pfcgx2p4wqh80000gn_T_main_11c959_mi_0);
        }

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[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 

        // 定义block变量
        void (* BlockOne)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA));

        // 执行block内部的源码
        ((void (*)(__block_impl *))((__block_impl *)BlockOne)->FuncPtr)((__block_impl *)BlockOne);

    }
    return 0;
}
static struct IMAGE_INFO { unsigned version; unsigned flag; } _OBJC_IMAGE_INFO = { 0, 2 };
复制代码

其中block的声明和调用的对应关系以下bash

image

删除其中的强制转换的相关代码后微信

// 定义block变量
void (* BlockOne)(void) = &__main_block_impl_0(
                                                (void *)__main_block_func_0,
                                                &__main_block_desc_0_DATA
                                            );

// 执行block内部的源码
BlockOne->FuncPtr(BlockOne);
复制代码

上述代码中__main_block_impl_0函数接受两个参数, 并有一个返回值, 最后把函数的地址返回给BlockOne, 下面找到__main_block_impl_0的定义markdown

// 结构体
struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  
  // c++中的构造函数, 相似于OC中的init方法
  // flags: 默认参数, 调用时可不传
  __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函数中的第一个参数__main_block_func_0赋值给了fp, fp又赋值给了impl.FuncPtr, 也就意味着impl.FuncPtr中存储的就是咱们要执行的__main_block_func_0函数的地址
  • Block结构体中的isa指向了_NSConcreteStackBlock, 说明Block是一个_NSConcreteStackBlock类型, 具体后面会详解
  • __main_block_impl_0函数中的第二个参数__main_block_desc_0_DATA
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)};
复制代码
  • 其中reserved赋值为0
  • Block_size被赋值为sizeof(struct __main_block_impl_0), 即为__main_block_impl_0这个结构体占用内存的大小
  • __main_block_impl_0的第二个参数, 接受的即为__main_block_desc_0结构体的变量(__main_block_desc_0_DATA)的地址

Block变量捕获

image

  • 局部变量分为两大类: auto和static
    • auto: 自动变量, 离开做用域就会自动销毁, 默认状况下定义的局部变量都是auto修饰的变量, 系统都会默认给添加一个auto
    • auto不能修饰全局变量, 会报错
    • static做用域内修饰局部变量, 能够修饰全局变量
  • 全局变量

局部变量

auto变量捕获

auto局部变量在Block中是值传递iphone

下述代码输出值为多少？函数

int age = 10;

void (^BlockTwo)(void) = ^(void){
    NSLog(@"age = %d，",age);
};

age = 13;
BlockTwo();
// 输出10
复制代码

输出值为何是10而不是13呢? 咱们仍是生成main.cpp代码看一下吧, 相关核心代码以下oop

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  // 这里多了一个age属性
  int age;
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _age, int flags=0) : age(_age) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  int age = __cself->age; // bound by copy

            NSLog((NSString *)&__NSConstantStringImpl__var_folders_ty_804897ld2zg4pfcgx2p4wqh80000gn_T_main_80d62b_mi_0,age);
        }

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[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;  
        // 定义属性
        int age = 10;

        // block的定义
        void (*BlockTwo)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, age));
        
        // 改变属性值
        age = 13;
        // 调用block
        ((void (*)(__block_impl *))((__block_impl *)BlockTwo)->FuncPtr)((__block_impl *)BlockTwo);
    }
    return 0;
}
static struct IMAGE_INFO { unsigned version; unsigned flag; } _OBJC_IMAGE_INFO = { 0, 2 };
复制代码

那么下面咱们一步步看一下, 吧一些强制转换的代码去掉以后spa

int age = 10;

void (*BlockTwo)(void) = &__main_block_impl_0(
                                            __main_block_func_0,
                                            &__main_block_desc_0_DATA,
                                            age
                                            );

age = 13;
BlockTwo->FuncPtr(BlockTwo);
复制代码

在上面的__main_block_impl_0函数里面相比于以前的, 多了一个age参数

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  // 新的属性age
  int age;
  // 构造函数, 多了_age参数
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _age, int flags=0) : age(_age) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
复制代码
  • 上面的构造方法__main_block_impl_0中, 多了一个_age参数
  • 同时后面多了一条age(_age)语句, 在c++中, age(_age)至关于age = _age, 即给age属性赋值, 存储构造函数传过来的age属性的值
  • 因此在后面调用block的时候, block对应的结构体所存储的age属性的值仍然是10, 并无被更新
// 及时这里从新对age进行了赋值
age = 13;

// 这里调用BlockTwo的时候, 结构体重的age属性的值并无被更新
BlockTwo->FuncPtr(BlockTwo);

// 最后在执行block内部逻辑的时候, 
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
    int age = __cself->age; // bound by copy
    // 这里的age, 仍然是block结构体中的age, 值并无改变, 因此输出结果仍是10
    NSLog((NSString *)&__NSConstantStringImpl__var_folders_ty_804897ld2zg4pfcgx2p4wqh80000gn_T_main_80d62b_mi_0,age);
}
复制代码

static变量捕获

static局部变量在Block中是指针传递, 看一下下面代码的输出状况

auto int age = 10;
static int weight = 20;

void (^BlockTwo)(void) = ^(void){
    NSLog(@"age = %d, weight = %d，",age, weight);
};

age = 13;
weight = 23;
BlockTwo();
复制代码
  • 上面代码输出结果: age = 10, weight = 23
  • 从新赋值后age的结果不变, 以前已经说过了
  • 但是weight的结果倒是赋值后的结果, 至于为何, 请继续向下看吧...
  • 咱们仍是生成main.cpp代码看一下吧, 相关核心代码以下
struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  int age;
  int *weight;
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _age, int *_weight, int flags=0) : age(_age), weight(_weight) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  int age = __cself->age; // bound by copy
  int *weight = __cself->weight; // bound by copy

            NSLog((NSString *)&__NSConstantStringImpl__var_folders_ty_804897ld2zg4pfcgx2p4wqh80000gn_T_main_282a93_mi_0,age, (*weight));
        }

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[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 
        auto int age = 10;
        static int weight = 20;

        void (*BlockTwo)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, age, &weight));

        age = 13;
        weight = 23;
        ((void (*)(__block_impl *))((__block_impl *)BlockTwo)->FuncPtr)((__block_impl *)BlockTwo);
    }
    return 0;
}
static struct IMAGE_INFO { unsigned version; unsigned flag; } _OBJC_IMAGE_INFO = { 0, 2 };
复制代码
  • 从上面代码能够看到__main_block_impl_0类中多了两个成员变量age和weight, 说明两个变量咱们均可以捕获到
  • 不一样的是, 一样都是int变量, 使用不一样的修饰词修饰, __main_block_impl_0类中也是不一样的
  • static修饰的变量weight在block中存储的是weight的地址, 在后面的block函数中咱们使用的也是其地址
int age;
int *weight;

// &weight
void (*BlockTwo)(void) = &__main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA, age, &weight);

// 下面构造方法中, 一样(weight(_weight)方法以前讲过)将传过来的weight的地址赋值给了 (int *weight;)
 __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _age, int *_weight, int flags=0) : age(_age), weight(_weight) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
}
复制代码
  • 也就是说上面的构造函数中
    • age保存的是一个准确的值
    • weight保存的是weight所在的内存地址
  • 因此在最后调用block内部逻辑的时候
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
    int age = __cself->age; // bound by copy
    int *weight = __cself->weight; // bound by copy

    // (*weight)至关于从weight的内存地址中取值, 在执行操做
    // 然而weight内存中的值已经在后面赋值的时候被更新了, 因此这里取出的值是赋值后的
    NSLog((NSString *)&__NSConstantStringImpl__var_folders_ty_804897ld2zg4pfcgx2p4wqh80000gn_T_main_282a93_mi_0,age, (*weight));
}
复制代码
  • 也就是说, 一样是局部变量
  • auto修饰的变量在block中存储的是变量的值(值传递)
  • static修饰的变量在block中存储的是变量的内存地址(地址传递)

全局变量

int age = 10;
static int weight = 20;

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        void (^BlockTwo)(void) = ^(void){
            NSLog(@"age = %d, weight = %d，",age, weight);
        };
        
        age = 13;
        weight = 23;
        BlockTwo();
    }
    return 0;
}
复制代码

上面代码的输出结果, 毫无疑问是13和23, 相关c++代码以下

int age = 10;
static int weight = 20;


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

            // 封装了block执行逻辑的函数
            NSLog((NSString *)&__NSConstantStringImpl__var_folders_ty_804897ld2zg4pfcgx2p4wqh80000gn_T_main_0ee0bb_mi_0,age, weight);
        }

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[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 

        // 定义block变量
        void (*BlockTwo)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA));

        age = 13;
        weight = 23;
        ((void (*)(__block_impl *))((__block_impl *)BlockTwo)->FuncPtr)((__block_impl *)BlockTwo);
    }
    return 0;
}
static struct IMAGE_INFO { unsigned version; unsigned flag; } _OBJC_IMAGE_INFO = { 0, 2 };
复制代码
  • 从上面代码能够看出__main_block_impl_0结构体重并无捕获到age和weight的成员变量
  • 一样在定义block变量的时候中也不须要传入age和weight的变量
  • 在封装了block执行逻辑的函数中, 就能够直接使用全局的变量便可

Block的类型

Block的三种类型

  • 在以前的C++源码中, __main_block_impl_0结构体中isa指向的类型是_NSConcreteStackBlock
  • 下面就具体看一下, Block的只要类型有那些
  • 先看一下下面这部分代码的输出结果
void (^block)(void) = ^(void){
    NSLog(@"Hello World");
};

NSLog(@"%@", [block class]);
NSLog(@"%@", [[block class] superclass]);
NSLog(@"%@", [[[block class] superclass] superclass]);
NSLog(@"%@", [[[[block class] superclass] superclass] superclass]);

/*
 2019-06-24 15:46:32.506386+0800 Block[3307:499032] __NSGlobalBlock__
 2019-06-24 15:46:32.506578+0800 Block[3307:499032] __NSGlobalBlock
 2019-06-24 15:46:32.506593+0800 Block[3307:499032] NSBlock
 2019-06-24 15:46:32.506605+0800 Block[3307:499032] NSObject
 */
复制代码
  • block的类型NSBlock最终也是继承自NSObject
  • 这也能够解释为何block的结构体__main_block_impl_0中会有一个isa指针了
  • 此外, block共有三种类型, 能够经过调用class方法或者isa指针查看具体类型, 最终都是继承自NSBlock类型
    • __NSGlobalBlock__或者_NSConcreteGlobalBlock
    • __NSStackBlock__或者_NSConcreteStackBlock
    • __NSMallocBlock__或者_NSConcreteMallocBlock

block在内存中的分配

  • _NSConcreteGlobalBlock: 在数据区域
  • _NSConcreteStackBlock: 在栈区域
  • _NSConcreteMallocBlock: 在堆区域

内存分配图

  • 应用程序的内存分配图如上图所示, 自上而下依次为内存的低地址-->内存的高地址
  • 程序区域: 代码段, 用于存放代码
  • 数据区域: 数据段, 用于存放全局变量
  • 堆: 动态分配内存，须要程序员本身申请，程序员本身管理, 一般是alloc或者malloc方式申请的内存
  • 栈: 用于存放局部变量, 系统会自动分配内存, 自动销毁内存

区分不一样的block类型

  • 上面提到, 一共有三种block类型, 且不一样的block类型存放在内存的不一样位置
  • 可是如何区分所定义的block 究竟是哪种类型呢 看看下面代码的执行状况, 运行环境实在MRC环境下
static int age = 10;
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        
        int weight = 21;
        void (^block1)(void) = ^(void){
            NSLog(@"Hello World");
        };
        void (^block2)(void) = ^(void){
            NSLog(@"age = %d", age);
        };
        void (^block3)(void) = ^(void){
            NSLog(@"age = %d", weight);
        };
        
        NSLog(@"block1 = %@", [block1 class]);
        NSLog(@"block2 = %@", [block2 class]);
        NSLog(@"block3 = %@", [block3 class]);
        
        /* 2019-06-24 21:13:14.555206+0800 Block[30548:1189724] block1 = __NSGlobalBlock__ 2019-06-24 21:13:14.555444+0800 Block[30548:1189724] block2 = __NSGlobalBlock__ 2019-06-24 21:13:14.555465+0800 Block[30548:1189724] block3 = __NSStackBlock__ */
    }
    return 0;
}
复制代码

针对各类不一样的block总结以下

block类型 环境
__NSGlobalBlock__ 没有访问auto变量
__NSStackBlock__ 访问了auto变量
__NSMallocBlock__ __NSStackBlock__调用了copy
  • 因为__NSMallocBlock__是放在堆区域
  • 要想建立出__NSMallocBlock__类型的block, 咱们能够调用copy方法
void (^block3)(void) = ^(void){
    NSLog(@"age = %d", weight);
};

NSLog(@"block3 = %@", [block3 class]);
NSLog(@"block3 = %@", [[block3 copy] class]);
/* 输出分别是: block3 = __NSStackBlock__ block3 = __NSMallocBlock__ */
复制代码
  • 从上面的代码中咱们能够明显看到, __NSStackBlock__类型的block调用copy方法后, 就会变成__NSMallocBlock__类型的block
  • 至关于生成的block是在堆区域的
  • 那么另外两种类型调用copy方法后,又会如何? 下面一块儿来看一下吧
int weight = 21;
void (^block1)(void) = ^(void){
    NSLog(@"Hello World");
};
void (^block3)(void) = ^(void){
    NSLog(@"age = %d", weight);
};

NSLog(@"block1 = %@", [block1 class]);
NSLog(@"block1 = %@", [[block1 copy] class]);
NSLog(@"block3 = %@", [block3 class]);
NSLog(@"block3 = %@", [[block3 copy] class]);
NSLog(@"block3 = %@", [[[block3 copy] copy] class]);
/* __NSGlobalBlock__ __NSGlobalBlock__ __NSStackBlock__ __NSMallocBlock__ __NSMallocBlock__ */
复制代码
  • 从上面的代码能够看到, 只有__NSStackBlock__类型的block调用copy以后才会变成__NSMallocBlock__类型, 其余的都是原类型
  • 主要也是__NSStackBlock__类型的做用域是在栈中, 做用域中的局部变量会在函数结束时自动销毁
  • __NSStackBlock__调用copy操做后，分配的内存地址至关于从栈复制到堆；副本存储位置是堆
  • 其余的则可参考下面表格
Block类 副本源的配置存储域 复制效果
__NSStackBlock__ 栈 从栈复制到堆
__NSGlobalBlock__ 程序的数据区域 什么也不作
__NSMallocBlock__ 堆 引用计数增长
  • 在ARC环境下, 编译器会根据状况自动将站上的block复制到堆上, 相似如下状况
    • block做为函数返回值时
    • 将block赋值给__strong修饰的指针时
    • block做为GCD的方法参数时

__block修饰符

Question: 定义一个auto修饰的局部变量, 并在block中修改该变量的值, 可否修改为功呢?

auto int width = 10;
static int height = 20;
void (^block)(void) = ^(void){
    // 事实证实, 在Xcode中这行代码是报错的
    width = 22;
    // 可是static修饰的变量, 倒是能够赋值, 不会报错
    height = 22;
    NSLog(@"width = %d, height = %d", width, height);
};

block();

// width = 10, height = 22
复制代码
  • 在以前提到, 在block中, auto修饰的变量是值传递
  • static修饰的变量是指针传递, 因此在上述代码中, block存储的只是height的内存地址
  • 一样auto变量实在main函数中定义的, 而block的执行逻辑是在__main_block_func_0结构体的方法中执行的, 至关于局部变量不能跨函数访问
  • 至于static修饰的变量为何能够修改?
    • 在__main_block_impl_0结构体中height存储的是其内存地址, 在其余函数或者结构体中访问和改变height的方式都是经过其真真访问的
    • 相似赋值方式: (*height) = 22;
    • 取值方式: (*height)

__block修饰auto变量

__block auto int width = 10;

void (^block)(void) = ^(void) {
    // 很明显, 这里就能够修改了
    width = 12;
    NSLog(@"width = %d", width);
};

block();
// width = 12
复制代码

为何上面的代码就能够修改变量了呢, 这是为何呢.....请看源码

下面是生成的block的结构体

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  
  // 这里的width被包装成了一个__Block_byref_width_0对象
  __Block_byref_width_0 *width; // by ref
  // 这里能够对比一下以前的未被__block修饰的int变量
  // int width;
  
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_width_0 *_width, int flags=0) : width(_width->__forwarding) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
复制代码
  • 上述代码看到__block能够用于解决block内部没法修改auto修饰的变量值得问题
  • 可是__block不能修饰全局变量和static修饰的静态变量(一样也不须要, 由于在block内部能够直接修改)
  • 通过__block修饰的变量会被包装成一个对象(__Block_byref_width_0)
  • 下面是width被包装后的对象的结构体, 在结构体内, 会有一个width成员变量
struct __Block_byref_width_0 {
  void *__isa;
  // 一个指向本身自己的成员变量
  __Block_byref_width_0 *__forwarding;
  int __flags;
  int __size;
  // 外部定义的auto变量
  int width;
};
复制代码

下面咱们先看一下, auto和block的定义和调用

int main(int argc, const char * argv[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 
        // __block auto int width = 10;
        auto __Block_byref_width_0 width = {
            0,
            &width,
            0,
            sizeof(__Block_byref_width_0),
            10
        };

        void (*block)(void) = &__main_block_impl_0(
            __main_block_func_0,
            &__main_block_desc_0_DATA,
            &width,
            570425344
        );

        block->FuncPtr(block);
    }
    return 0;
}
复制代码
  • 能够看到在定义的__Block_byref_width_0类型的width中的每个参数分别赋值给了__Block_byref_width_0结构体中的每个成员变量
  • 而在block内部从新对width从新赋值的逻辑中
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
    __Block_byref_width_0 *width = __cself->width; // bound by ref

    (width->__forwarding->width) = 12;
    NSLog((NSString *)&__NSConstantStringImpl__var_folders_ty_804897ld2zg4pfcgx2p4wqh80000gn_T_main_9241d5_mi_0, (width->__forwarding->width));
}
复制代码
  • 上面代码中的width是一个__Block_byref_width_0类型的变量
  • width对象经过找到内部的__forwarding成员变量
  • 在__Block_byref_width_0结构体中__forwarding是一个指向本身自己的成员变量
  • 因此最后再经过__forwarding找到__Block_byref_width_0的成员变量width, 在进行从新赋值
  • 在NSLog中也是经过这种逻辑获取width的值

欢迎您扫一扫下面的微信公众号，订阅个人博客！

微信公众号
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程