百度360必应搜狗淘宝本站头条
nodejsbufferorg.jsoupsetnocountoncv2.bitwise_nottime.strptime
当前位置：网站首页 > 编程字典 > 正文

深入理解 OCC++ 闭包

toyiye 2024-06-21 11:56 8 浏览 0 评论

背景

苹果的 Objective-C 编译器允许用户在同一个源文件里自由地混合使用 C++和 Objective-C，混编后的语言叫 Objective-C++。相对于其它语言（例如 Swift、Kotlin、Dart 等）和 C++的文件隔离和架桥通信（例如 Kotlin 使用JNI，Dart 使用FFI），Objective-C 和 C++的同文件混编方式无疑是令人舒畅的。OC/C++混编虽然可以在一个文件中进行编写，但是有一些注意事项需要了解：Objective-C++没有为 OC 类增加 C++的功能，也没有为 C++增加 OC 的功能，例如：不能用 OC 语法调用 C++对象，也不能为 OC 对象增加构造函数和析构函数，也不能将this和self互相替换使用。类的体系结构是独立的，C++类不能继承 OC 类，OC 类也不能继承 C++类。

本文主要就之前令人困惑的 OC 的Block和 C++的lambda混编问题做一些探索。

实验环境：C++版本为 C++14，OC 只局限于 ARC。

基本了解

在深入探索之前，先通过对比的方式了解下二者：

语法

^(int x, NSString *y){} // ObjC, take int and NSString*
[](int x, std::string y){} // C++, take int and std::string

^{ return 42; } // ObjC, returns int
[]{ return 42; } // C++, returns int

^int { if(something) return 42; else return 43; }
[]()->int { if(something) return 42; else return 43; }

原理

OC 的Block的底层可以参考《深入研究 Block 捕获外部变量和 __block 实现原理》（https://halfrost.com/ios_block/），这里不做深入探究，仅仅是要展开代码达到对比效果。

- (void)viewDidLoad {
    [super viewDidLoad];

    int x = 3;
    void(^block)(int) = ^(int a) {
        NSLog(@"%d", x);
    };
    block(5);
}

通过clang -rewrite-objc重写，可以得到以下结果：

struct __ViewController__viewDidLoad_block_impl_0 {
  struct __block_impl impl;
  struct __ViewController__viewDidLoad_block_desc_0* Desc;
  int x;
  __ViewController__viewDidLoad_block_impl_0(void *fp, struct __ViewController__viewDidLoad_block_desc_0 *desc, int _x, int flags=0) : x(_x) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
static void __ViewController__viewDidLoad_block_func_0(struct __ViewController__viewDidLoad_block_impl_0 *__cself, int a) {
   int x = __cself->x; // bound by copy
   NSLog((NSString *)&__NSConstantStringImpl__var_folders_st_jhg68rvj7sj064ft0rznckfh0000gn_T_ViewController_d02516_mii_0, x);
}

static struct __ViewController__viewDidLoad_block_desc_0 {
  size_t reserved;
  size_t Block_size;
} __ViewController__viewDidLoad_block_desc_0_DATA = { 0, sizeof(struct __ViewController__viewDidLoad_block_impl_0)};

static void _I_ViewController_viewDidLoad(ViewController * self, SEL _cmd) {
    ((void (*)(__rw_objc_super *, SEL))(void *)objc_msgSendSuper)((__rw_objc_super){(id)self, (id)class_getSuperclass(objc_getClass("ViewController"))}, sel_registerName("viewDidLoad"));
    int x = 3;
    void(*block)(int) = ((void (*)(int))&__ViewController__viewDidLoad_block_impl_0((void *)__ViewController__viewDidLoad_block_func_0, &__ViewController__viewDidLoad_block_desc_0_DATA, x));
    ((void (*)(__block_impl *, int))((__block_impl *)block)->FuncPtr)((__block_impl *)block, 5);
}

而 C++ lambda采取了截然不同的的实现机制，会把lambda表达式转换为一个匿名 C++类。这里借助cppinsights 看下 C++ lambda的实现。

#include <cstdio>

struct A {
  int x;
  int y;
};

int main()
{
    A a = {1, 2};
    int m = 3;
    auto add = [&a, m](int n)->int {
        return m + n + a.x + a.y;
    };
    m = 30;
    add(20);
}

#include <cstdio>

struct A
{
    int x;
    int y;
};

int main()
{
    A a = {1, 2};
    int m = 3;

    class __lambda_12_15
    {
    public:
        inline int operator()(int n) const
        {
            return ((m + n) + a.x) + a.y;
        }

    private:
        A & a;
        int m;

    public:
        __lambda_12_15(A & _a, int & _m)
        : a{_a}
        , m{_m}
        {}
    };

    __lambda_12_15 add = __lambda_12_15{a, m};
    m = 30;
    add.operator()(20);
    return 0;
}

可以看到：lambda表达式add被转换为类__lambda_12_15，且重载了操作符()，对add的调用也被转换为对add.operator()的调用。

捕获变量

OC Block只可能通过普通方式和__block方式捕获变量：

int x = 42;
void (^block)(void) = ^{ printf("%d\n", x); };
block(); // prints 42

__block int x = 42;
void (^block)(void) = ^{ x = 43; };
block(); // x is now 43

C++ lambda带来了更多的灵活性，可以通过以下这些方式捕获变量：

[] Capture nothing
[&] Capture any referenced variable by reference
[=] Capture any referenced variable by making a copy
[=, &foo] Capture any referenced variable by making a copy, but capture variable foo by reference
[bar] Capture bar by making a copy; don't copy anything else
[this] Capture the this pointer of the enclosing class

int x = 42;
int y = 99;
int z = 1001;
auto lambda = [=, &z] {
    // can't modify x or y here, but we can read them
    z++;
    printf("%d, %d, %d\n", x, y, z);
};
lambda(); // prints 42, 99, 1002
// z is now 1002

内存管理

OC 的Block和 C++ lambda均起源于栈对象，然而二者的后续发展截然不同。OC 的Block本质是 OC 对象，他们是通过引用方式存储，从来不会通过值方式存储。为了延长生命周期，OC Block必须被拷贝到堆上。OC Block遵循 OC 的引用计数规则，copy和release必须平衡（Block_copy和Block_release同理）。首次拷贝会把Block从栈上移动到堆上，再次拷贝会增加其引用计数。当引用计数为 0 的时候，Block会被销毁，其捕获的对象会被release。

C++ lambda按值存储，而非按引用存储。所有捕获的变量都会作为匿名类对象的成员变量存储到匿名类对象中。当lambda表达式被拷贝的时候，这些变量也都会被拷贝，只需要触发适当的构造函数和析构函数即可。这里面有一个极其重要的点：通过引用捕获变量。这些变量是作为引用存储在匿名对象中的，他们并没有得到任何特殊待遇。这意味着这些变量的生命周期结束之后，lambda仍然有可能会去访问这些变量，从而造成未定义的行为或者崩溃，例如：

 - (void)viewDidLoad {
    [super viewDidLoad];

    int x = 3;
    lambda = [&x]() -> void {
        NSLog(@"x = %d", x);
    };
}

- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
    lambda();
}

// 从输出结果中可以看到x是一个随机值
2022-02-12 23:15:01.375925+0800 BlockTest[63517:1006998] x = 32767

相对来说，this指向的存储在堆上，它的生命周期有一定的保证，但是即使如此，也无法绝对保证生命周期安全，有些情况下需要借助智能指针延长生命周期。

auto strongThis = shared_from_this();
doSomethingAsynchronously([strongThis, this]() {
    someMember_ = 42;
});

闭包混合捕获问题

前面讨论的内容都是相互独立的，OC 的Block并未涉及 C++对象，C++的lambda也没有牵扯 OC 对象，这大概是我们最希望看到的，但是混编过程中会发现这只是自己的一厢情愿。二者往往会相互把自己的魔杖伸向对方领域，从而会引发一些比较费解的问题。

C++的lambda捕获OC对象

C++的lambda可以捕获 OC 变量吗？如果可以的话，会有循环引用的问题吗？如果有循环引用的问题，该怎么处理呢？

值捕获 OC 对象

如代码所示，在OCClass类中有一个 C++字段cppObj，在OCClass的初始化方法中，对cppObj进行了初始化，并对其字段callback进行了赋值。可以看到，在lambda中对self进行了捕获，按照前面的规则，可以认为值捕获。

class CppClass {
public:
    CppClass() {
    }

    ~CppClass() {
    }
public:
    std::function<void()> callback;
};

@implementation OCClass {
    std::shared_ptr<CppClass> cppObj;
}

- (void)dealloc {
    NSLog(@"%s", __FUNCTION__);
}

- (instancetype)init {
    if (self = [super init]) {
        cppObj = std::make_shared<CppClass>();
        cppObj->callback = [self]() -> void {
            [self executeTask];
        };
    }
    return self;
}

- (void)executeTask {
    NSLog(@"execute task");
}

OCClass *ocObj = [[OCClass alloc] init];

不幸的是，这样的捕获方式会发生循环引用：OCClass对象ocObj持有cppObj，cppObj通过callback持有了ocObj。

看下对应的汇编代码，可以发现捕获的时候，触发了ARC语义，自动对self进行了retain。

这几行汇编代码对self增加引用计数。

0x10cab31ea <+170>: movq   -0x8(%rbp), %rdi
0x10cab31ee <+174>: movq   0x5e7b(%rip), %rax        ; (void *)0x00007fff2018fa80: objc_retain
0x10cab31f5 <+181>: callq  *%rax

最后来看一下匿名类的参数，可以发现self是OCClass *类型，是一个指针类型。

那么可以简单地认为捕获伪代码如下，在ARC语义下会发生retain行为：

__strong __typeof(self) capture_self = self;

// 展开
__strong OCClass * capture_self = self;

为了解决循环引用的问题，可以使用__weak。

cppObj = std::make_shared<CppClass>();
__weak __typeof(self) wself = self;
cppObj->callback = [wself]() -> void {
    [wself executeTask];
};

再次观察汇编代码，发现前面的objc_retain逻辑已经消失，代替的逻辑为objc_copyWeak。

引用捕获 OC 对象

那么是否可以通过引用捕获来捕获self呢？

cppObj = std::make_shared<CppClass>();
cppObj->callback = [&self]() -> void {
    [self executeTask];
};

可以看到汇编代码中同样没有objc_retain逻辑。

最后来看一下匿名类的参数，可以发现self是OCClass *&类型，是一个指针引用类型。

可以看到引用捕获并不会对self进行retain，可以简单的认为捕获伪代码如下，在ARC语义下不会发生retain行为。

__unsafe_unretained __typeof(self)& capture_self = self;

// 展开
__unsafe_unretained OCClass *&capture_self = self;

被捕获的 OC 对象什么时候释放？

以这个代码片段为例：

auto cppObj = std::make_shared<CppClass>();
OCClass2 *oc2 = [[OCClass2 alloc] init];
cppObj->callback = [oc2]() -> void {
    [oc2 class];
};

可以看到，在CppClass的析构函数中对std::function进行了析构，而std::function则对其捕获的 OC 变量 oc2 进行了释放。

结论

C++ lambda的本质是创建一个匿名结构体类型，用来存储捕获的变量。ARC会保证包含 OC 对象字段的 C++结构体类型遵循ARC语义：

  1. C++结构体的构造函数会将 OC 对象字段初始化为nil；
  2. 当该 OC 对象字段被赋值的时候，会release掉之前的值，并retain新值（如果是block，会进行copy）；
  3. 当 C++结构体的析构函数被调用的时候，会release掉 OC 对象字段。

C++ lambda会通过值或者引用的方式捕获 OC 对象。

  1. 引用捕获 OC 对象相当于使用__unsafe_unretained，存在生命周期问题，本身比较危险，不太推荐；
  2. 而值捕获的方式相当于使用__strong，可能会引起循环引用，必要的时候可以使用__weak。

OC 的 Block 如何捕获 C++对象？

反过来看看 OC 的Block是怎么捕获 C++对象的。

代码中的HMRequestMonitor是一个 C++结构体，其中的WaitForDone和SignalDone方法主要是为了实现同步。

struct HMRequestMonitor  {
public:
    bool WaitForDone() { return is_done_.get(); }
    void SignalDone(bool success) { done_with_success_.set_value(success); }
    ResponseStruct& GetResponse() { return response_; }
private:
    .....
};

upload方法使用HMRequestMonitor对象，达到同步等待网络请求结果的目的（为了排版，代码有所调整）。

hermas::ResponseStruct HMUploader::upload(
const char* url,
const char* request_data,
int64_t len,
const char* header_content_type,
const char* header_content_encoding) {
    HMRequestModel *model = [[HMRequestModel alloc] init];
    ......

    auto monitor = std::make_shared<hermas::HMRequestMonitor>();
    std::weak_ptr<hermas::HMRequestMonitor> weakMonitor(monitor);
    DataResponseBlock block = ^(NSError *error, id data, NSURLResponse *response) {
        weakMonitor.lock()->SignalDone(true);
    };
    [m_session_manager requestWithModel:model callBackWithResponse:block];
    monitor->WaitForDone();
    return monitor->GetResponse();
}

这里直接使用std::weak_ptr。

不使用__block

通过实验可以得到以下结论：

  1. C++的对象会被 OC 的Block捕获，且通过值传递方式。通过断点可以发现调用的是std::weak_ptr的拷贝构造函数。
template<class _Tp>
inline
weak_ptr<_Tp>::weak_ptr(weak_ptr const& __r) _NOEXCEPT
    : __ptr_(__r.__ptr_),
      __cntrl_(__r.__cntrl_)
{
    if (__cntrl_)
        __cntrl_->__add_weak();
}
  1. monitor的弱引用计数变化如下：
  • 初始化monitor时， weak_count = 1;
  • 初始化weakMonitor时，weak_count = 2，增加 1；
  • OC Block 捕获后，weak_count = 4，增加了 2。通过观察汇编代码，有 2 处：
    • 首次捕获的时候，对weakMinotor进行了复制，在汇编代码 142 行；
    • Block从栈上拷贝到堆上的时候，再次对weakMinotor进行了复制，在汇编 144 行；

这里需要注意的是：C++的weak_count比较奇怪，它的值 = 弱引用个数 + 1，这么设计的原因比较复杂，具体可以参考：https://stackoverflow.com/questions/5671241/how-does-weak-ptr-work

如果此处不使用std::weak_ptr，而是直接捕获std::shared_ptr，被捕获后其强引用计数为 3，逻辑和上述的std::weak_ptr是一致的。（就本质上来说，std::shared_ptr和std::weak_ptr都是 C++类）

std::shared_ptr<hermas::HMRequestMonitor> monitor = std::make_shared<hermas::HMRequestMonitor>();
DataResponseBlock block = ^(NSError * _Nonnull error, id  _Nonnull data, NSURLResponse * _Nonnull response) {
    monitor->SignalDone(true);
};

(lldb) po monitor
std::__1::shared_ptr<hermas::HMRequestMonitor>::element_type @ 0x00006000010dda58 strong=3 weak=1

使用__block

那么是否可以使用__block修改被捕获的 C++变量呢？通过实验发现是可行的。

可以得到以下结论：

  1. OC 的Block可以通过引用传递方式捕获 C++对象；
  2. monitor的weak引用计数如下：
  • 初始化monitor时， weak_count = 1;
  • 初始化weakMonitor时，weak_count = 2，增加 1；
  • OC Block捕获后，weak_count = 2，主要是由于移动构造函数被触发，只是所有权的转移，不会改变引用计数；

__block 的疑问

了解 C++的同学可能会疑惑，这里既然是移动构造函数被触发，只是所有权发生了转移，意味着monitor作为右值被传递进来，已经变为nullptr被消亡，那么为什么示例中的monitor还可以继续访问？可以来验证一下：

  1. 当首次执行完如下代码的时候

会发现monitor变量的地址为：

(lldb) po &monitor
0x0000700001d959e8
  1. 当执行block赋值的时候，会调用到std::shared_ptr的移动构造函数中：

  • 移动构造函数中的this地址为0x0000600003b0c830;
  • __r的地址也是0x0000700001d959e8，和monitor的地址一致。
  1. 当执行完block的时候，再次打印monitor的地址，会发现monitor的地址已经发生了变化，和第二步中的this保持了一致，这说明monitor已经变为第二步中的this。
(lldb) po &monitor
0x0000600003b0c830

整个过程中，monitor前后地址发生了变化，分别是 2 个不同的std::shared_ptr对象。所以monitor还可以继续被访问。

被捕获的 C++对象何时释放？

同样在 OC 的Block释放的时候，会对其捕获的 C++对象进行释放。

捕获 shared_from_this

C++的this是一个指针，本质就是一个整数，OC 的Block捕获this和捕获一个整数并没有本质上的区别，所以这里不再详细讨论。这里重点看下 C++的shared_from_this类，它是 this 的智能指针版本。

一个 C++类如果想访问shared_from_this，必须继承自类enable_shared_from_this，并把自己的类名作为模板参数传入。

class CppClass : public std::enable_shared_from_this<CppClass> {
public:
    CppClass(){}
    ~CppClass() {}

    void attachOCBlock();
public:
    OCClass2 *ocObj2;
    void dosomething() {}
};

void CppClass::attachOCBlock() {
    ocObj2 = [[OCClass2 alloc] init];
    auto shared_this = shared_from_this();
    ocObj2.ocBlock = ^{
        shared_this->dosomething();
    };
}

@interface OCClass2 : NSObject
@property void (^ocBlock)();
@end

auto cppObj = std::make_shared<CppClass>();
cppObj->attachOCBlock();

根据前面的结论，在CppClass成员函数attachOCBlock中，ocBlock直接捕获shared_from_this同样会引发循环引用，同样采取std::weak_ptr来解决。

void CppClass::attachOCBlock() {
    ocObj2 = [[OCClass2 alloc] init];
    std::weak_ptr<CppClass> weak_this = shared_from_this();
    ocObj2.ocBlock = ^{
        weak_this.lock()->dosomething();
    };
}

结论

OC 的Block可以捕获 C++对象。

  1. 如果使用普通方式捕获栈上的 C++对象，会调用拷贝构造函数；
  2. 如果使用__block方式捕获栈上的 C++对象，会调用移动构造函数，并且__block修饰的 C++对象在被捕获的时候，会进行重定向。

总结

本文一开始分别从语法、原理、变量捕获和内存管理 4 个维度，对 OC 的Block和 C++的lambda进行了简单的对比，然后花了较多的篇幅重点讨论 OC/C++的闭包混合捕获问题。之所以如此大费周章，是因为不想稀里糊涂地「猜想」和「试错」，只有深入了解背后机制，才能写出较好的 OC/C++混编代码，同时也希望能给有同样困惑的读者带来一些帮助。然而对于 OC/C++整个混编领域来说，这仅仅是冰山一角，疑难问题仍然重重，期待未来能带来更多的探索。

参考文档

  1. https://isocpp.org/wiki/faq/objective-c
  2. http://www.philjordan.eu/article/mixing-objective-c-c++-and-objective-c++
  3. https://releases.llvm.org/12.0.0/tools/clang/docs/AutomaticReferenceCounting.html
  4. https://releases.llvm.org/12.0.0/tools/clang/docs/BlockLanguageSpec.html#c-extensions
  5. https://mikeash.com/pyblog/friday-qa-2011-06-03-objective-c-blocks-vs-c0x-lambdas-fight.html

相关推荐

为何越来越多的编程语言使用JSON（为什么编程）

JSON是JavascriptObjectNotation的缩写，意思是Javascript对象表示法，是一种易于人类阅读和对编程友好的文本数据传递方法，是JavaScript语言规范定义的一个子...

何时在数据库中使用 JSON（数据库用json格式存储）

在本文中，您将了解何时应考虑将JSON数据类型添加到表中以及何时应避免使用它们。每天?分享?最新?软件?开发?，Devops，敏捷?，测试?以及?项目?管理?最新?，最热门?的?文章?，每天?花?...

MySQL 从零开始:05 数据类型（mysql数据类型有哪些,并举例）

前面的讲解中已经接触到了表的创建，表的创建是对字段的声明，比如：上述语句声明了字段的名称、类型、所占空间、默认值和是否可以为空等信息。其中的int、varchar、char和decimal都...

JSON对象花样进阶（json格式对象）

一、引言在现代Web开发中，JSON（JavaScriptObjectNotation）已经成为数据交换的标准格式。无论是从前端向后端发送数据，还是从后端接收数据，JSON都是不可或缺的一部分。...

深入理解 JSON 和 Form-data（json和formdata提交区别）

在讨论现代网络开发与API设计的语境下，理解客户端和服务器间如何有效且可靠地交换数据变得尤为关键。这里，特别值得关注的是两种主流数据格式：...

JSON 语法（json 语法 priority）

JSON语法是JavaScript语法的子集。JSON语法规则JSON语法是JavaScript对象表示法语法的子集。数据在名称/值对中数据由逗号分隔花括号保存对象方括号保存数组JS...

JSON语法详解（json的语法规则）

JSON语法规则JSON语法是JavaScript对象表示法语法的子集。数据在名称/值对中数据由逗号分隔大括号保存对象中括号保存数组注意：json的key是字符串,且必须是双引号，不能是单引号...

MySQL JSON数据类型操作（mysql的json）

概述mysql自5.7.8版本开始，就支持了json结构的数据存储和查询，这表明了mysql也在不断的学习和增加nosql数据库的有点。但mysql毕竟是关系型数据库，在处理json这种非结构化的数据...

JSON的数据模式（json数据格式示例）

像XML模式一样，JSON数据格式也有Schema，这是一个基于JSON格式的规范。JSON模式也以JSON格式编写。它用于验证JSON数据。JSON模式示例以下代码显示了基本的JSON模式。{"...

前端学习——JSON格式详解（后端json格式）

JSON(JavaScriptObjectNotation)是一种轻量级的数据交换格式。易于人阅读和编写。同时也易于机器解析和生成。它基于JavaScriptProgrammingLa...

什么是 JSON:详解 JSON 及其优势（什么叫json）

现在程序员还有谁不知道JSON吗？无论对于前端还是后端，JSON都是一种常见的数据格式。那么JSON到底是什么呢？JSON的定义...

PostgreSQL JSON 类型:处理结构化数据

PostgreSQL提供JSON类型，以存储结构化数据。JSON是一种开放的数据格式，可用于存储各种类型的值。什么是JSON类型？JSON类型表示JSON(JavaScriptO...

JavaScript:JSON、三种包装类（javascript 包）

JOSN:我们希望可以将一个对象在不同的语言中进行传递，以达到通信的目的，最佳方式就是将一个对象转换为字符串的形式JSON（JavaScriptObjectNotation）-JS的对象表示法...

Python数据分析 只要1分钟 教你玩转JSON 全程干货

Json简介：Json，全名JavaScriptObjectNotation,JSON(JavaScriptObjectNotation(记号、标记))是一种轻量级的数据交换格式。它基于J...

比较一下JSON与XML两种数据格式?（json和xml哪个好）

JSON（JavaScriptObjectNotation）和XML（eXtensibleMarkupLanguage）是在日常开发中比较常用的两种数据格式，它们主要的作用就是用来进行数据的传...

取消回复欢迎 你 发表评论:

请填写验证码
一周热门
最近发表
标签列表