深入理解 Objective-C Block 与 C++ Lambda

背景

Objective-C++ 允许在同一个翻译单元中同时使用 Objective-C 和 C++。这种能力省去了跨语言桥接层,但并不会合并两套对象模型:Objective-C 对象仍由 ARC 和 Objective-C Runtime 管理,C++ 对象仍遵循构造、拷贝、移动与析构规则。

真正容易出错的地方,是两种闭包开始捕获对方语言中的对象。例如,C++ lambda 捕获 Objective-C 对象时是否会触发 ARC?Objective-C Block 捕获 shared_ptr 或 weak_ptr 时会调用拷贝构造还是移动构造?这些行为又会不会形成循环引用或悬垂引用?

本文通过编译器展开结果、汇编和引用计数变化回答这些问题,重点讨论两类场景:

  1. C++ lambda 捕获 Objective-C 对象;
  2. 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
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; }

调用模型

Objective-C Block 的底层结构可参考《深入研究 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 表达式生成匿名闭包类。下面借助 cppinsights 查看其近似展开结果:

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,该类重载了 operator();调用 add 最终也被转换为调用 add.operator()。

捕获变量

Objective-C 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

内存管理

Objective-C Block 是 Objective-C 对象,运行时存在全局、栈和堆等不同实现形态。需要延长栈 Block 的生命周期时,复制操作会把它及其捕获数据迁移到堆上;在 ARC 下,这些复制与释放通常由编译器自动管理。被强捕获的 Objective-C 对象会随 Block 一起保持有效,直到相应所有权被释放。

C++ 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 本质上只保存一个原始指针,同样不会延长对象生命周期。无论对象位于栈上还是堆上,只要 lambda 可能晚于对象执行,就需要通过其他所有权机制保证其有效性,例如捕获适当的智能指针。

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

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
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 持有 cppObj,而 cppObj 又通过 callback 中按值捕获的 self 强持有 ocObj。

Objective-C 对象与 C++ 回调之间形成循环引用

从对应的汇编可以看到,捕获过程触发了 ARC 所有权语义,编译器为 self 生成了 retain 操作。

lambda 按值捕获 self 时生成的 objc_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

再看匿名闭包类的字段,self 的类型是 OCClass *,即一个受 ARC 管理的 Objective-C 对象指针。

lambda 闭包对象中的 Objective-C 指针字段

因此,可以将这次按值捕获近似理解为下面的伪代码:闭包对象保存一个强引用字段,并由 ARC 管理其所有权。

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

// 展开
__strong OCClass * capture_self = self;

需要打破循环引用时,可以先用 __weak 声明弱引用,再让 lambda 按值捕获这个弱引用。

1
2
3
4
5
cppObj = std::make_shared<CppClass>();
__weak __typeof(self) wself = self;
cppObj->callback = [wself]() -> void {
[wself executeTask];
};
捕获弱引用后生成的 objc_copyWeak 调用

再次观察汇编,前面的 objc_retain 已经消失,取而代之的是 objc_copyWeak。

按引用捕获 Objective-C 对象

另一种选择是按引用捕获 self:

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

汇编中同样没有出现 objc_retain。

lambda 按引用捕获 self 时的汇编结果

匿名闭包类中的字段类型为 OCClass *&,说明闭包保存的是外部指针变量的引用,而不是一份独立的 Objective-C 对象指针。

按引用捕获后闭包对象中的 Objective-C 指针引用字段

按引用捕获不会让 lambda 对目标对象建立独立的强引用,可以近似理解为下面的伪代码。需要注意,它引用的是外部变量本身;一旦 lambda 晚于该变量的生命周期执行,就会产生悬垂引用。它与 __unsafe_unretained 都不负责延长对象生命周期,但两者的实现机制并不相同。

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

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

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

以这个代码片段为例:

1
2
3
4
5
auto cppObj = std::make_shared<CppClass>();
OCClass2 *oc2 = [[OCClass2 alloc] init];
cppObj->callback = [oc2]() -> void {
[oc2 class];
};
std::function 析构时释放捕获的 Objective-C 对象

可以看到,CppClass 析构时会销毁 std::function,闭包对象随后按照 ARC 语义释放其捕获的 Objective-C 对象 oc2。

结论

C++ lambda 会生成一个闭包对象,并把捕获项保存为字段。在 Objective-C++ 与 ARC 环境下,Objective-C 对象指针字段仍然保留自己的所有权修饰符,编译器会在闭包对象的构造、复制、移动和析构过程中生成对应的 ARC 操作。

因此可以得到三点结论:

  1. 按值捕获普通 Objective-C 对象指针通常会形成独立的强引用,可能引发循环引用;
  2. 按值捕获 __weak 指针会保留弱引用语义,可以用于打破循环;
  3. 按引用捕获不会建立独立强引用,但要求外部变量在 lambda 执行期间始终有效,否则会产生悬垂引用。

Objective-C Block 捕获 C++ 对象

反过来,再看 Objective-C Block 如何保存 C++ 对象,以及这个过程会触发哪些特殊成员函数。 示例中的 HMRequestMonitor 是一个 C++ 结构体,其中 WaitForDone 和 SignalDone 用于同步请求状态。

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
19
20
21
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) {
auto strongMonitor = weakMonitor.lock();
if (strongMonitor) {
strongMonitor->SignalDone(true);
}
};
[m_session_manager requestWithModel:model callBackWithResponse:block];
monitor->WaitForDone();
return monitor->GetResponse();
}

这里直接使用 std::weak_ptr,避免回调反向延长业务对象的生命周期。

不使用 __block

Block 捕获 weak_ptr 时触发拷贝构造 Block 从栈复制到堆时再次复制 weak_ptr

实验可以得到以下结论:

  1. Objective-C Block 会按值捕获普通 C++ 自动变量;断点显示这里调用了 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();
}
  1. 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
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 后,Block 可以修改被捕获的 C++ 变量。根据 Clang 的 Block 语义,在 C++11 环境下,__block 变量迁移到转发存储时会优先按 xvalue 移动;无法移动时才尝试复制。

__block 捕获 C++ 对象时触发移动构造 __block 转发存储中的 C++ 智能指针

由此可以得到以下结论:

  1. Objective-C Block 可以通过 __block 转发存储共享 C++ 对象;
  2. 初始化 monitor 时,weak_count = 1;初始化 weakMonitor 后,weak_count = 2;Block 捕获后仍为 2;
  3. 迁移 __block 存储时触发的是移动构造,所有权发生转移,但引用计数不会额外增加。
__block 捕获前后 weak_ptr 引用计数变化

__block 变量为何仍然可访问?

这里有一个容易混淆的问题:既然迁移过程调用了移动构造函数,原来的 monitor 是否已经变为空对象?为什么示例代码之后仍然可以通过同名变量访问它?可以通过地址变化验证 __block 转发机制:

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

1
2
(lldb) po &monitor 
0x0000700001d959e8

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

__block 变量迁移时 shared_ptr 移动构造函数的参数地址 __block 转发后 monitor 变量指向新的存储地址
  1. 移动构造函数中的this地址为0x0000600003b0c830;
  2. __r的地址也是0x0000700001d959e8,和monitor的地址一致

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

1
2
(lldb) po &monitor 
0x0000600003b0c830

迁移前后的 monitor 位于两个不同的 std::shared_ptr 对象中。源码中的变量访问会通过 __block 转发指针落到新的存储位置,因此同名变量仍然可以继续使用。

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

Objective-C 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
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 中直接捕获 shared_from_this() 同样可能形成循环引用。解决方式仍然是让 Block 捕获 std::weak_ptr,执行时再临时提升为 std::shared_ptr。

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

结论

Objective-C Block 可以保存 C++ 对象,但具体行为取决于捕获方式:

  1. 普通捕获会把 C++ 对象复制进 Block 的捕获区,并调用相应的拷贝构造函数;
  2. __block 捕获会通过转发存储共享变量。在 C++11 环境下,存储迁移时会优先调用移动构造函数;
  3. 捕获原始指针不会延长对象生命周期,捕获 shared_ptr 则可能参与形成循环引用。

总结

Objective-C++ 允许两种语言写在同一个文件中,但不会替我们统一它们的对象模型。跨语言捕获时,ARC 所有权修饰符、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
-------------本文结束 感谢您的阅读-------------
坚持原创技术分享,您的支持将鼓励我继续创作!

本文标题:深入理解 Objective-C Block 与 C++ Lambda

文章作者:lingyun

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

最后更新:2026年10月07日 - 00:10

原始链接:https://tsuijunxi.github.io/2022/02/14/%E6%B7%B1%E5%85%A5%E7%90%86%E8%A7%A3-OC-C-%E9%97%AD%E5%8C%85/

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