[iOS]Block系列探究二 - 捕获变量

最新推荐文章于 2024-08-24 15:32:26 发布
最新推荐文章于 2024-08-24 15:32:26 发布
阅读量119 收藏
点赞数
文章标签： c/c++
原文链接：https://juejin.im/post/5cd278e0f265da039378808d
版权

上一篇文章中我们得知了OC的block其实就是C的函数指针，这一篇文章我们来研究下block与局部变量的各种化学反应。

一、截获变量

我们主要截获三种变量，分别是全局变量、静态全局变量、布局变量、静态局部变量，代码如下：

/** 全局变量 */
int global_count = 10;
/** 静态全局变量 */
static int static_global_count = 10;

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // 声明block
        void (^block)(void);
        // 局部变量
        int count = 10;
        // 静态局部变量
        static int static_count = 10;
        // block的实现
        block = ^{
            global_count = 11;
            static_global_count = 11;
            NSLog(@"count = %@", @(count));
            static_count = 11;
        };
        // block的调用
        block();
        // 重新赋值
        global_count = 12;
        static_global_count = 12;
        count = 12;
        static_count = 12;
    }
    return 0;
}
复制代码

上面代码，我们向block传了一个参数count，现在我们clang一下，得到下面的C/C++代码：

// __block_imp结构体
struct __block_impl {
  void *isa;
  int Flags;
  int Reserved;
  void *FuncPtr;
};

int global_count = 10;

static int static_global_count = 10;

// __main_block_impl_0结构体
struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  int count;
  int *static_count;
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _count, int *_static_count, int flags=0) : count(_count), static_count(_static_count) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

// __main_block_func_0函数
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  int count = __cself->count; // bound by copy
  int *static_count = __cself->static_count; // bound by copy

            global_count = 11;
            static_global_count = 11;
            NSLog((NSString *)&__NSConstantStringImpl__var_folders_0r_hkkmpct143n4wd3xxk0l1j8c0000gn_T_main_23de66_mi_0, ((NSNumber *(*)(Class, SEL, int))(void *)objc_msgSend)(objc_getClass("NSNumber"), sel_registerName("numberWithInt:"), (int)(count)));
            (*static_count) = 11;
        }

// __main_block_desc_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)};

// main函数
int main(int argc, const char * argv[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 

        void (*block)(void);

        int count = 10;

        static int static_count = 10;

        block = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, count, &static_count));

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

        global_count = 12;
        static_global_count = 12;
        count = 12;
        static_count = 12;
    }
    return 0;
}
复制代码

我们重点看一下__main_block_impl_0这个结构体：

// __main_block_impl_0结构体
struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  int count;
  int *static_count;
  
  /** 
  这里需要说明的是：冒号语法后面的内容相当于为参数成员count初始化
  int count = _count; 
  */
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _count, int *_static_count, int flags=0) : count(_count), static_count(_static_count) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
复制代码

我们可以看到__main_block_impl_0结构体多了两个成员变量count和static_count。 在声明block时，count的值就已经被保存到了__main_block_impl_0结构体内部，注意这里是值传递，也就是说在调用前对count重新赋值，并不会影响到__main_block_impl_0结构体内部的count成员变量的值。 同样的，在声明block是，静态变量static_count的指针被保存到了__main_block_impl_0结构体内部，因为是引用传递，所以block内部对static_count的修改会直接影响到static_count的值。 全局变量global_count和静态全局变量static_global_count因为作用域是全局的，所以block内部的修改会直接影响到它们的值。

二、__block说明符

我们都知道block是无法修改外部的局部变量的值的，但是__block却可以让我们修改外部的局部变量的值，接下来我们探索一下原因。 首先，上OC代码：

// 声明block
void (^block)(void);
__block int count = 10;
// block的实现
block = ^{
    count = 11;
};
// block的调用
block();
// 给count重新赋值
count = 12;
复制代码

我们clang一下，得到下面代码：

// __block_impl结构体
struct __block_impl {
  void *isa;
  int Flags;
  int Reserved;
  void *FuncPtr;
};

// __Block_byref_count_0结构体
struct __Block_byref_count_0 {
  void *__isa;
__Block_byref_count_0 *__forwarding;
 int __flags;
 int __size;
 int count;
};

// __main_block_impl_0结构体
struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  __Block_byref_count_0 *count; // by ref
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_count_0 *_count, int flags=0) : count(_count->__forwarding) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

// __main_block_func_0函数
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
    __Block_byref_count_0 *count = __cself->count; // bound by ref
    (count->__forwarding->count) = 11;
}

// __main_block_copy_0函数
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {_Block_object_assign((void*)&dst->count, (void*)src->count, 8/*BLOCK_FIELD_IS_BYREF*/);}

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

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

        void (*block)(void);
        __attribute__((__blocks__(byref))) __Block_byref_count_0 count = {(void*)0,(__Block_byref_count_0 *)&count, 0, sizeof(__Block_byref_count_0), 10};

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

        ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
        
        (count.__forwarding->count) = 12;
    }
    return 0;
}
复制代码

我们发现，__main_block_desc_0结构体多了成员变量copy和dispose，另外还多了几个函数和结构体，分别是__Block_byref_count_0结构体、__main_block_copy_0函数和__main_block_dispose_0函数。

2.1、__Block_byref_count_0结构体

我们首先看一下__Block_byref_count_0这个结构体，代码如下：

// __Block_byref_count_0结构体
struct __Block_byref_count_0 {
  void *__isa;
__Block_byref_count_0 *__forwarding;
 int __flags;
 int __size;
 int count 
};
复制代码

这个结构体是__block变量的包装，相当于OC的对象，我们看一下main()函数中该结构体的初始化函数：

 __attribute__((__blocks__(byref))) __Block_byref_count_0 count = {(void*)0,(__Block_byref_count_0 *)&count, 0, sizeof(__Block_byref_count_0), 10};
复制代码

我们可以看到结构体中最后的成员变量相当于原局部变量，从成员变量名和初始化函数也可以看出。 我们来具体看一下__block变量的赋值：

// block的实现
block = ^{
    count = 11;
};
复制代码

这段代码的转换如下：

// __main_block_func_0函数
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
    __Block_byref_count_0 *count = __cself->count; // bound by ref
    (count->__forwarding->count) = 11;
}
复制代码

__main_block_impl_0结构体实例持有指向__block变量的__Block_byref_count_0结构体实例的指针。 __Block_byref_count_0结构体实例的成员变量__forwarding持有指向该实例自身的指针。通过成员变量__forwarding访问成员变量count。成员变量count是该实例自身持有的变量，它相当于局部变量。

`__forwarding`变量、`__main_block_copy_0`函数和`__main_block_dispose_0`函数存在的意义我们会在下一篇文章`Block存储域`中探究。
三、总结

我们总结一下，block捕获变量分以下几种情况：

  • 变量为全局变量和静态全局变量时，block没有额外处理，直接拿来用；
  • 变量为局部变量时，只能捕获在声明block前的变量的值，在block内部不能修改该变量的值。
  • 变量为静态局部变量时，捕获该变量的指针，在block内部可以修改该变量的值。
  • 变量为被__block修饰过的局部变量是，该变量被包装成结构体（OC对象），该结构体的最后一个成员变量为被__block修饰过的局部变量，block捕获该结构体的指针，在block内部可以修改该变量的值。

转载于:https://juejin.im/post/5cd278e0f265da039378808d

weixin_34309435
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
iOS之深入解析Block的使用和外部变量捕获
╰つ栺尖篴夢ゞ
03-16 3万+
一、前言 闭包 = 一个函数「或指向函数的指针」+ 该函数执行的外部的上下文变量「也就是自由变量」; Block是Objective-C对于闭包的实现。 其中，Block: 可以嵌套定义，定义Block方法和定义函数方法相似； Block 可以定义在方法内部或外部； 只有调用Block时候，才会执行其{}体内的代码； 本质是对象，使代码高聚合。 使用 clang 将 OC 代码转换为 C++ 文件查看block的方法: 在命令行输入代码 clang -rewrite-objc 需要编译的OC文件
iOS开发——block底层实现与变量捕获
原来是泽镜的博客
08-04 480
前言 首发地址：block底层实现与变量捕获 带着问题阅读 block的本质是什么？你能讲出来它的底层结构吗？ 全局变量会被block捕获吗？block会捕获哪些变量？ block的底层数据结构 block又叫代码块，是OC语法中非常重要的一个概念，我们先来看一下Block的简单使用。 int main(int argc, const char * argv[]) { @autoreleasepool { ^{ NSLog(@"hello block");
iOS block捕获变量
qq_34954017的博客
10-31 553
block针对不同类型的变量的捕获
iOS — block捕获自动变量的值
我是闰土你是猹的博客
10-15 418
int val = 10; void (^blk)(void) = ^{printf("val=%d\n",val);}; val = 2; blk(); 上面这段代码输出值是：val = 10,而不是2，block截获自动变量的瞬时值。因为block保存了自动变量的值，所以在执行block语法后，即使改写block中使用的自动变量的值也不会影响block执行时自动变量的值。 尝试改写blo...
iOS block以及变量捕获
weixin_45157020的博客
01-13 694
可以看到，在block的内部多了成员变量_age，并且在构造这个block时，会把age的值直接传进去，几_age=age，可以看出来这时是block捕获了局部变量，并且进行了值传递。可以看到全局变量没有捕获到block内部，是直接访问的，所以每次访问都能获得最新值。可以看出来age传递的是值，但是静态局部变量height传递的是指针。clang编译后的底层代码。1、局部变量和block。使用局部变量的block。3、全局变量和block。不同类型变量的捕获方式。
iOS底层系列之＜9＞--Block（二）变量捕获Capture
JH_Cao的博客
12-31 671
block难度递增中！
iOS中block变量捕获原理详析
01-20
然而，需要注意的是，Block捕获变量可能会导致强引用循环（retain cycle），尤其是在Block内部持有对象实例时。为了避免这种情况，可以使用弱引用（`__weak`）或使用`__unsafe_unretained`关键字来弱化对象引用。 ...
iOS在Block中修改外部变量值的实现代码
08-29
Block能够捕获并存储其定义时所在上下文中的变量值，这包括了外部变量。然而，不是所有的外部变量都可以在Block内部被修改。本篇文章将详细解释如何在Block中修改外部变量值，并通过示例代码进行演示。 首先，我们...
iOS进阶 - Block底层原理
12-25
#### 二、Block的变量捕获机制 为了确保Block内部可以正确访问外部的变量，Block设计了一套捕获机制。当Block创建时，会自动捕获其作用域内的所有变量。这些变量会被复制到Block内部的数据结构中，从而保证Block...
iOS学习——block深入浅出-代码
11-20
2. **Block捕获局部变量**： Block可以捕获其定义时的作用域内的局部变量。这使得Block可以访问这些变量，即使在Block被调用时，原始作用域已经不再存在。但是，如果局部变量是可变对象（如NSMutableArray），Block...
学习C语言 第十九天
zh060515的博客
08-21 642
指程序的行为在 C 语言标准中没有明确定义，因此可以表现为任何结果。当程序出现未定义行为时，可能会产生不可预测的结果，包括程序崩溃、数据损坏、安全漏洞，甚至可能看起来正常运行。比如比较两个 NaN（非数字）值是否相等，这是未定义的行为。
编程中 编辑/编译 高级语言和机器语言的感悟
a_black_的博客
08-22 494
编辑程序：用于编写和修改代码，没有执行功能。编译程序：将代码转换为机器代码，允许计算机执行程序。C语言代码是高级语言，易于人类理解和编写。机器代码是计算机能直接执行的低级语言，以二进制形式存在，通常很难理解。
C语言刷题日记(附详解)(2)
ixiaotang_的博客
08-24 1134
你所厌恶的今天，是昨天死去之人奢望的明天。你所浪费的现在，是未来的你回不去的曾经。时间如此宝贵，作为学生，学习就是我们的职责，那么不要懈怠！让我们开始今天的学习吧！
【pip镜像设置】pip使用清华镜像源安装
前端探索者
08-21 1918
PyPI的镜像站点是用于加速Python包下载的服务器，它们提供了与官方PyPI相同的内容，但可能会因为地理位置更近而下载速度更快。进行python 的第三方库安装，但是，有时会出现。使用了清华大学的镜像网站。
基于YOLO V8的PCB缺陷检测识别系统（python源码+Pyqt5界面+数据集+训练代码）
2401_83580557的博客
08-22 427
基于YOLO V8的PCB缺陷检测识别系统【python源码+Pyqt5界面+数据集+训练代码】
QT Quick QML 实例之定制 TableView
最新发布
火山上的企鹅
08-24 325
视图（如ListView）中请求模型的数据时，视图会调用 data() 函数，并传递相应的 QModelIndex 和 role， data() 函数会根据这些参数返回对应的数据。编辑数据: 当用户在视图中编辑数据（如在表格单元格中输入文本或选择复选框）时，视图会调用 setData() 函数，模型根据提供的新数据更新相应的项。：setData() 用于更新数据，而 data() 则用于获取数据。headerData() 通常与 data() 一起使用，前者用于表头的显示，后者用于表格中具体单元格的显示。
C程序设计——常量
tianshigexing的专栏
08-20 394
/ 1小时 == 3600秒上述源码就表示定义了一个整数类型的常量 I_XIAO_SHI。I_XIAO_SHI 叫做常量名。上述源码中，定义I_XIAO_SHI的时候，直接给它赋值了。这种在定义时赋值的操作，叫做初始化。用const 定义的常量只能初始化，不能赋值。如果你拥有一个好的编程风格，常量名全部用大写字母。char，unsigned char，short int……等所有整数、无符号整数类型，都可以通过const 关键字定义常量。
QT C++上位机软件开发，相比较C#上位机软件开发，有哪些特点和区别
曾经的我也很优秀，现在的我一无所有。
08-20 409
在开发上位机软件时，选择使用Qt C++还是C#取决于多种因素，包括项目需求、团队技能、开发速度等因素。
iOS编程：深入理解Block
- **需要避免的模式**：避免循环引用，特别是当Block捕获强引用的对象时，可能导致内存泄漏。 - **调试**：Xcode提供了调试Block的功能，可以查看Block的内存地址和捕获的变量值。 Block编程在iOS开发中扮演着...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值