背景
Objective-C++ 允许在同一个翻译单元中同时使用 Objective-C
和
C++。这种能力省去了跨语言桥接层,但并不会合并两套对象模型:Objective-C
对象仍由 ARC 和 Objective-C Runtime 管理,C++
对象仍遵循构造、拷贝、移动与析构规则。
真正容易出错的地方,是两种闭包开始捕获对方语言中的对象。例如,C++
lambda 捕获 Objective-C 对象时是否会触发 ARC?Objective-C Block 捕获
shared_ptr 或 weak_ptr
时会调用拷贝构造还是移动构造?这些行为又会不会形成循环引用或悬垂引用?
本文通过编译器展开结果、汇编和引用计数变化回答这些问题,重点讨论两类场景:
- C++ lambda 捕获 Objective-C 对象;
- Objective-C Block 捕获 C++ 对象。
实验范围:Objective-C++、C++14 与 ARC。
先看结论
| 对比项 | Objective-C Block | C++ lambda |
|---|---|---|
| 运行时形态 | 带有调用入口和捕获数据的 Objective-C 对象 | 编译器生成、重载了 operator() 的闭包对象 |
| 默认捕获 | 普通自动变量按值导入;__block 变量通过转发存储共享 |
根据捕获列表按值或按引用保存 |
| 生命周期 | 存在全局、栈和堆等实现形态;ARC 负责多数复制与释放操作 | 遵循普通 C++ 对象的作用域、拷贝、移动与析构规则 |
| 捕获另一种语言的对象 | 捕获 C++ 对象时调用相应的拷贝或移动构造 | Objective-C 指针字段按照其 ARC 所有权修饰符管理 |
| 主要风险 | C++ 对象的复制成本、__block 转发和所有权变化 |
强捕获造成循环引用,引用捕获造成生命周期风险 |
Objective-C Block 与 C++ Lambda 的基础差异
先从语法、调用模型、变量捕获和内存管理四个方面进行对比。
语法
1 | ^(int x, NSString *y){} // ObjC, take int and NSString* |
调用模型
Objective-C Block 的底层结构可参考《深入研究 Block 捕获外部变量和 __block 实现原理》。这里不重复完整实现,只借助编译器展开结果观察它的调用入口和捕获数据。
1 | - (void)viewDidLoad { |
通过 clang -rewrite-objc 展开后,可以得到以下结构:
1 | struct __ViewController__viewDidLoad_block_impl_0 { |
C++ lambda 采用另一套实现机制:编译器会为 lambda
表达式生成匿名闭包类。下面借助 cppinsights
查看其近似展开结果:
1 |
|
可以看到,lambda 表达式 add 被转换为类
__lambda_12_15,该类重载了 operator();调用
add 最终也被转换为调用 add.operator()。
捕获变量
Objective-C Block 主要通过普通捕获和 __block
捕获两种方式处理局部变量:
1 | int x = 42; |
C++ lambda 的捕获列表更加灵活,可以显式选择按值、按引用或混合捕获:
1 | [] Capture nothing |
内存管理
Objective-C Block 是 Objective-C 对象,运行时存在全局、栈和堆等不同实现形态。需要延长栈 Block 的生命周期时,复制操作会把它及其捕获数据迁移到堆上;在 ARC 下,这些复制与释放通常由编译器自动管理。被强捕获的 Objective-C 对象会随 Block 一起保持有效,直到相应所有权被释放。
C++ lambda 则是普通的闭包对象。按值捕获的变量成为闭包对象的成员,并随闭包对象执行拷贝、移动和析构;按引用捕获不会延长外部变量的生命周期。如果 lambda 在外部变量销毁后仍访问该引用,行为是未定义的,严重时会直接崩溃。例如:
1 | - (void)viewDidLoad { |
捕获 this
本质上只保存一个原始指针,同样不会延长对象生命周期。无论对象位于栈上还是堆上,只要
lambda
可能晚于对象执行,就需要通过其他所有权机制保证其有效性,例如捕获适当的智能指针。
1 | auto strongThis = shared_from_this(); |
Objective-C++ 中的跨语言捕获
前面的例子都停留在各自的对象模型中。实际的 Objective-C++ 工程却经常需要跨语言捕获:lambda 保存 Objective-C 对象,或者 Block 保存 C++ 对象。此时 ARC 与 C++ 特殊成员函数会同时参与,生命周期关系也更容易被误判。
C++ lambda 捕获 Objective-C 对象
C++ lambda 可以捕获 Objective-C 对象,但捕获方式会决定是否建立强引用,以及 lambda 能否安全地晚于外部变量执行。
按值捕获 Objective-C 对象
下面的 OCClass 持有一个 C++ 字段
cppObj。初始化 cppObj 后,代码为其
callback 设置一个按值捕获 self 的 lambda。
1 | class CppClass { |
1 | OCClass *ocObj = [[OCClass alloc] init]; |
这里会形成循环引用:OCClass 实例 ocObj 持有
cppObj,而 cppObj 又通过 callback
中按值捕获的 self 强持有 ocObj。
从对应的汇编可以看到,捕获过程触发了 ARC 所有权语义,编译器为
self 生成了 retain 操作。
下面几行汇编对应 self 引用计数的增加:
1 | 0x10cab31ea <+170>: movq -0x8(%rbp), %rdi |
再看匿名闭包类的字段,self 的类型是
OCClass *,即一个受 ARC 管理的 Objective-C 对象指针。
因此,可以将这次按值捕获近似理解为下面的伪代码:闭包对象保存一个强引用字段,并由 ARC 管理其所有权。
1 | __strong __typeof(self) capture_self = self; |
需要打破循环引用时,可以先用 __weak 声明弱引用,再让
lambda 按值捕获这个弱引用。
1 | cppObj = std::make_shared<CppClass>(); |
再次观察汇编,前面的 objc_retain 已经消失,取而代之的是
objc_copyWeak。
按引用捕获 Objective-C 对象
另一种选择是按引用捕获 self:
1 | cppObj = std::make_shared<CppClass>(); |
汇编中同样没有出现 objc_retain。
匿名闭包类中的字段类型为
OCClass *&,说明闭包保存的是外部指针变量的引用,而不是一份独立的
Objective-C 对象指针。
按引用捕获不会让 lambda
对目标对象建立独立的强引用,可以近似理解为下面的伪代码。需要注意,它引用的是外部变量本身;一旦
lambda 晚于该变量的生命周期执行,就会产生悬垂引用。它与
__unsafe_unretained
都不负责延长对象生命周期,但两者的实现机制并不相同。
1 | __unsafe_unretained __typeof(self)& capture_self = self; |
被捕获的 Objective-C 对象何时释放?
以这个代码片段为例:
1 | auto cppObj = std::make_shared<CppClass>(); |
可以看到,CppClass 析构时会销毁
std::function,闭包对象随后按照 ARC 语义释放其捕获的
Objective-C 对象 oc2。
结论
C++ lambda 会生成一个闭包对象,并把捕获项保存为字段。在 Objective-C++ 与 ARC 环境下,Objective-C 对象指针字段仍然保留自己的所有权修饰符,编译器会在闭包对象的构造、复制、移动和析构过程中生成对应的 ARC 操作。
因此可以得到三点结论:
- 按值捕获普通 Objective-C 对象指针通常会形成独立的强引用,可能引发循环引用;
- 按值捕获
__weak指针会保留弱引用语义,可以用于打破循环; - 按引用捕获不会建立独立强引用,但要求外部变量在 lambda 执行期间始终有效,否则会产生悬垂引用。
Objective-C Block 捕获 C++ 对象
反过来,再看 Objective-C Block 如何保存 C++
对象,以及这个过程会触发哪些特殊成员函数。 示例中的
HMRequestMonitor 是一个 C++ 结构体,其中
WaitForDone 和 SignalDone
用于同步请求状态。
1 | struct HMRequestMonitor { |
upload 方法通过 HMRequestMonitor
同步等待网络请求结果。为了突出捕获关系,示例省略了与问题无关的代码。
1 | hermas::ResponseStruct HMUploader::upload( |
这里直接使用
std::weak_ptr,避免回调反向延长业务对象的生命周期。
不使用 __block
实验可以得到以下结论:
- Objective-C Block 会按值捕获普通 C++ 自动变量;断点显示这里调用了
std::weak_ptr的拷贝构造函数。
1 | template<class _Tp> |
monitor的弱引用计数变化如下:- 初始化
monitor时,weak_count = 1; - 初始化
weakMonitor时,weak_count = 2; - Block 捕获后,
weak_count = 4。其中一次增长来自求值 Block 字面量时对weakMonitor的复制,另一次来自栈 Block 被复制到堆上时的再次复制。
- 初始化
weak_count的数值不一定等于表面上的弱引用数量。其控制块实现通常还包含内部计数,具体机制可参考 How does weak_ptr work?。
如果改为直接捕获 std::shared_ptr,同样会触发 C++
对象的复制,只是变化的是强引用计数。下面的实验中,Block
建立后强引用计数为 3:
1 | std::shared_ptr<hermas::HMRequestMonitor> monitor = std::make_shared<hermas::HMRequestMonitor>(); |
1 | (lldb) po monitor |
使用 __block
使用 __block 后,Block 可以修改被捕获的 C++ 变量。根据
Clang 的 Block 语义,在 C++11 环境下,__block
变量迁移到转发存储时会优先按 xvalue 移动;无法移动时才尝试复制。
由此可以得到以下结论:
- Objective-C Block 可以通过
__block转发存储共享 C++ 对象; - 初始化
monitor时,weak_count = 1;初始化weakMonitor后,weak_count = 2;Block 捕获后仍为2; - 迁移
__block存储时触发的是移动构造,所有权发生转移,但引用计数不会额外增加。
__block
变量为何仍然可访问?
这里有一个容易混淆的问题:既然迁移过程调用了移动构造函数,原来的
monitor
是否已经变为空对象?为什么示例代码之后仍然可以通过同名变量访问它?可以通过地址变化验证
__block 转发机制:
当首次执行完如下代码的时候会发现
monitor变量的地址为:
1 | (lldb) po &monitor |
当执行
block赋值的时候,会调用到std::shared_ptr的移动构造函数中:
- 移动构造函数中的this地址为0x0000600003b0c830;
- __r的地址也是0x0000700001d959e8,和monitor的地址一致
当执行完
block的时候,再次打印monitor的地址,会发现monitor的地址已经发生了变化,和第二步中的this保持了一致,这说明monitor已经变为第二步中的this
1 | (lldb) po &monitor |
迁移前后的 monitor 位于两个不同的
std::shared_ptr 对象中。源码中的变量访问会通过
__block
转发指针落到新的存储位置,因此同名变量仍然可以继续使用。
被捕获的 C++ 对象何时释放?
Objective-C Block 销毁时,也会析构保存在捕获区中的 C++ 对象。
捕获 shared_from_this
C++ 的 this 是原始指针,Block
捕获它并不会自动延长对象生命周期。需要共享所有权时,可以通过继承
std::enable_shared_from_this 获取受 shared_ptr
管理的当前对象。
C++ 类需要继承
std::enable_shared_from_this<T>,并且对象本身已经由std::shared_ptr管理,才能安全调用shared_from_this()。
1 | class CppClass : public std::enable_shared_from_this<CppClass> { |
1 | @interface OCClass2 : NSObject |
1 | auto cppObj = std::make_shared<CppClass>(); |
根据前面的结论,在 CppClass::attachOCBlock 中直接捕获
shared_from_this() 同样可能形成循环引用。解决方式仍然是让
Block 捕获 std::weak_ptr,执行时再临时提升为
std::shared_ptr。
1 | void CppClass::attachOCBlock() { |
结论
Objective-C Block 可以保存 C++ 对象,但具体行为取决于捕获方式:
- 普通捕获会把 C++ 对象复制进 Block 的捕获区,并调用相应的拷贝构造函数;
__block捕获会通过转发存储共享变量。在 C++11 环境下,存储迁移时会优先调用移动构造函数;- 捕获原始指针不会延长对象生命周期,捕获
shared_ptr则可能参与形成循环引用。
总结
Objective-C++ 允许两种语言写在同一个文件中,但不会替我们统一它们的对象模型。跨语言捕获时,ARC 所有权修饰符、C++ 特殊成员函数和闭包自身的生命周期会同时生效。
判断这类问题时,与其只看捕获语法,不如依次回答三个问题:闭包对象实际保存了什么字段?复制或迁移闭包时调用了哪些操作?闭包与被捕获对象之间最终形成了怎样的所有权关系?只要把这三层关系展开,循环引用、悬垂引用和额外复制通常都能被准确定位。
发布说明:本文也曾发表于微信公众号《深入理解 OC/C++ 闭包》,博客版本为持续维护版本。
参考文档
- https://isocpp.org/wiki/faq/objective-c
- http://www.philjordan.eu/article/mixing-objective-c-c++-and-objective-c++
- https://releases.llvm.org/12.0.0/tools/clang/docs/AutomaticReferenceCounting.html
- https://releases.llvm.org/12.0.0/tools/clang/docs/BlockLanguageSpec.html#c-extensions
- https://mikeash.com/pyblog/friday-qa-2011-06-03-objective-c-blocks-vs-c0x-lambdas-fight.html