深入理解 OC/C++ 闭包

该文章同步发表于微信公众号:<<深入理解 OC/C++ 闭包>>

背景

苹果的Objective-C编译器允许用户在同一个源文件里自由地混合使用C++Objective-C,混编后的语言叫Objective-C++。相对于其它语言(例如SwiftKotlinDart等)和C++的文件隔离和架桥通信(例如Kotlin使用JNIDart使用FFI),Objective-CC++的同文件混编方式无疑是令人舒畅的。OC/C++混编虽然可以在一个文件中进行编写,但是有一些注意事项需要了解:Objective-C++没有为OC类增加C++的功能,也没有为C++增加OC的功能,例如:不能用OC语法调用C++对象,也不能为OC对象增加构造函数和析构函数,也不能将thisself互相替换使用。类的体系结构是独立的,C++类不能继承OC类,OC类也不能继承C++类。
本文主要就之前令人困惑的OCBlockC++lambda混编问题做一些探索。

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

基本了解

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

语法

1
2
3
4
5
6
7
8
^(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; }

原理

OCBlock的底层可以参考<<深入研究 Block 捕获外部变量和 __block 实现原理>>,这里不做深入探究,仅仅是要展开代码达到对比效果。

1
2
3
4
5
6
7
8
9
- (void)viewDidLoad {
[super viewDidLoad];

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
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的实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
#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方式捕获变量:

1
2
3
4
5
6
7
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带来了更多的灵活性,可以通过以下这些方式捕获变量:

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

内存管理

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
- (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指向的存储在堆上,它的生命周期有一定的保证,但是即使如此,也无法绝对保证生命周期安全,有些情况下需要借助智能指针延长生命周期。

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

闭包混合捕获问题

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

C++lambda捕获OC对象

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

值捕获OC对象

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
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");
}

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

不幸的是,这样的捕获方式会发生循环引用:OCClass对象ocObj持有cppObjcppObj通过callback持有了ocObj

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

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

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

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

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

1
2
3
4
__strong __typeof(self) capture_self = self;

// 展开
__strong OCClass * capture_self = self;

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

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

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

引用捕获OC对象

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

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

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

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

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

1
2
3
4
__unsafe_unretained __typeof(self)& capture_self = self;

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

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

以这个代码片段为例:

1
2
3
4
5
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++结构体的析构函数被调用的时候,会releaseOC对象字段。

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

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

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

反过来看看OCBlock是怎么捕获C++对象的。
代码中的HMRequestMonitor是一个C++结构体,其中的WaitForDoneSignalDone方法主要是为了实现同步。

1
2
3
4
5
6
7
8
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对象,达到同步等待网络请求结果的目的(为了排版,代码有所调整)。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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++的对象会被OCBlock捕获,且通过值传递方式。通过断点可以发现调用的是std::weak_ptr的拷贝构造函数。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    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();
    }
  2. 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_ptrstd::weak_ptr都是C++类)

1
2
3
4
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);
};

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

使用__block

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

可以得到以下结论:

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

__block的疑问

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

当首次执行完如下代码的时候会发现monitor变量的地址为:

1
2
(lldb) po &monitor 
0x0000700001d959e8

当执行block赋值的时候,会调用到std::shared_ptr的移动构造函数中:

  1. 移动构造函数中的this地址为0x0000600003b0c830;
  2. __r的地址也是0x0000700001d959e8,和monitor的地址一致

当执行完block的时候,再次打印monitor的地址,会发现monitor的地址已经发生了变化,和第二步中的this保持了一致,这说明monitor已经变为第二步中的this

1
2
(lldb) po &monitor 
0x0000600003b0c830

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

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

同样在OCBlock释放的时候,会对其捕获的C++对象进行释放

捕获shared_from_this

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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();
};
}
1
2
3
@interface OCClass2 : NSObject
@property void (^ocBlock)();
@end
1
2
auto cppObj = std::make_shared<CppClass>();
cppObj->attachOCBlock();

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

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

结论

OCBlock可以捕获C++对象。

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

总结

本文一开始分别从语法、原理、变量捕获和内存管理4个维度,对OCBlockC++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
-------------本文结束 感谢您的阅读-------------

本文标题:深入理解 OC/C++ 闭包

文章作者:lingyun

发布时间:2022年02月14日 - 16:02

最后更新:2022年08月06日 - 17:08

原始链接:https://tsuijunxi.github.io/2022/02/14/深入理解-OC-C-闭包/

许可协议: 署名-非商业性使用-禁止演绎 4.0 国际 转载请保留原文链接及作者。