Chapter 34: Lambda Expressions
核心问题与阅读主线
Lambda 表达式在工程上不是“匿名短函数”,而是带有唯一闭包类型、捕获成员与调用运算符的对象实例。判断 lambda 进入 STL 算法后的存储成本、复制行为与悬垂风险,核心在于拆解这个闭包对象的成员布局、所有权与生命周期。
全章共用代码样本(下文各节持续拆解)
本章贯穿下面这个任务调度场景:urgent_for_owner 谓词捕获筛选参数进入 std::count_if,无捕获比较器决定 std::stable_sort 的排序顺序。
#include <algorithm>
#include <cstdint>
#include <string>
#include <tuple>
#include <vector>
struct Job {
std::string owner;
int priority;
std::uint64_t deadline;
};
void schedule(std::vector<Job>& jobs, std::uint64_t now) {
std::string current_owner = "build";
int priority_floor = 5;
auto urgent_for_owner = [current_owner, priority_floor, &now](const Job& job) {
return job.owner == current_owner &&
job.priority >= priority_floor &&
job.deadline <= now + 60;
};
std::stable_sort(jobs.begin(), jobs.end(), [](const Job& lhs, const Job& rhs) {
return std::tie(lhs.deadline, rhs.priority) <
std::tie(rhs.deadline, lhs.priority);
});
auto urgent_count = std::count_if(jobs.begin(), jobs.end(), urgent_for_owner);
(void)urgent_count;
}
C++ 工作草案在 lambda expressions 中将 lambda 定义为构造 function object 的表达式:求值产生 closure object(闭包对象),其类型为编译器生成的 closure type(闭包类型)。STL 算法接收并保存的正是这个对象,而非裸函数。
34.1 closure type 与 lambda 对象模型
Lambda 求值生成闭包对象(closure object),其编译器生成的闭包类型(closure type)具有两个属性:
- 唯一性:即使两个 lambda 源码完全相同,各自生成的闭包类型也互不相同。
- 未命名性:无法直接写出类型名,通常通过
auto、模板参数或类型擦除包装器持有。
贯穿示例中的 urgent_for_owner 既不是函数指针,也不是 std::function,其概念上的对象布局与调用接口如下:
struct UrgentForOwnerClosure {
std::string current_owner;
int priority_floor;
std::uint64_t& now;
bool operator()(const Job& job) const {
return job.owner == current_owner &&
job.priority >= priority_floor &&
job.deadline <= now + 60;
}
};
该对象模型直接解释了三个接口行为:
operator()使闭包对象满足std::count_if的一元可调用要求。- 值捕获的
current_owner与priority_floor成为闭包对象自有的成员变量。 - 引用捕获的
now作为引用成员,调用时读取外部变量的当前值。
捕获列表直接决定闭包的存储成本:空捕获 lambda 通常为空类,值捕获则会把字符串、容器或智能指针等状态嵌入闭包对象。
关键事实
C++ 标准允许编译器调整闭包类型的大小、对齐及部分类属性(只要不改变程序可观察行为)。工程上应将闭包体积视为实现相关,而将捕获对象的所有权与生命周期视为代码自身责任。
无捕获 lambda 不依赖外部实例状态,在参数与返回类型匹配时可转换为普通函数指针;带捕获 lambda 必须依赖闭包成员保存环境,无法退化为仅含代码入口的函数指针:
auto plain = [](int x) { return x + 1; };
int (*fp)(int) = plain;
int bias = 1;
auto with_state = [bias](int x) { return x + bias; };
// int (*bad)(int) = with_state; // 带捕获闭包需要对象状态,无法按普通函数指针保存。
贯穿示例中的 std::stable_sort 比较器虽不持有状态,仍属于独立的闭包类型;STL 算法不感知 lambda 语法,只接收并调用闭包对象。
34.2 value capture、reference capture 与生命周期
捕获列表决定闭包成员的存储形态、状态可见性与生命周期边界,常见捕获方式的工程取舍如下:
| 捕获方式 | 闭包成员形态 | 外部修改可见性 | 生命周期要求 | 典型适用场景 |
|---|---|---|---|---|
[x] 值捕获 | 成员副本 | 不可见(创建时快照) | 独立于原局部对象 | 筛选阈值快照、逃逸闭包 |
[&x] 引用捕获 | 引用成员 | 可见(读取调用时当前值) | 外部对象须覆盖调用期 | 局部同步算法、共享计数器 |
[x = expr] 初始化捕获 | 显式初始化成员 | 取决于表达式类型 | 由转移或构造后的成员决定 | 转移 std::unique_ptr 等 move-only 对象 |
[this] 指针捕获 | 当前对象指针 | 可见(经指针访问成员) | 原对象须覆盖调用期 | 同期对象内回调 |
[*this] 副本捕获 | 当前对象副本 | 不可见(对象快照) | 独立于原对象 | 异步任务、生命周期跨出当前对象 |
值捕获将创建时的参数快照存为闭包成员。贯穿示例的 urgent_for_owner 创建后,即便外部 current_owner 或 priority_floor 随后改动,闭包内部仍维持创建时的条件:
std::string current_owner = "build";
int priority_floor = 5;
const auto urgent_for_owner = [current_owner, priority_floor](const Job& job) {
return job.owner == current_owner && job.priority >= priority_floor;
};
current_owner = "test";
priority_floor = 9;
// urgent_for_owner 仍按 "build" 和 5 判断。
当值捕获 lambda 传入 STL 算法时,算法通常按值接收并复制整个闭包对象,捕获成员也会按各自类型的复制或移动语义一并拷贝。捕获状态越大或复制语义越复杂,越需要核查拷贝开销与异常安全性。
引用捕获在调用时读取外部对象当前值。贯穿示例的 &now 允许算法运行期间观察最新时间,前提是 std::count_if 在 schedule 返回前执行完毕、now 始终存活:
auto near_deadline = [&now](const Job& job) {
return job.deadline <= now + 60;
};
now += 30;
// near_deadline 下一次调用会看到更新后的 now。
若闭包生命周期超过外部局部对象,引用捕获就会演变为悬垂引用:
#include <functional>
std::function<bool(const Job&)> make_filter() {
std::string owner = "build";
return [&owner](const Job& job) {
return job.owner == owner;
};
}
边界与误区
make_filter 返回后局部对象 owner 立即销毁,返回的闭包仍持有对它的引用,后续调用直接进入未定义行为。凡会离开当前函数的闭包,禁止引用捕获局部变量或捕获 [this] 裸指针。
C++14 引入的初始化捕获允许在捕获列表直接声明并初始化闭包成员。将 make_filter 改为通过初始化捕获移动所有权即可消除悬垂:
std::function<bool(const Job&)> make_filter(std::string owner) {
return [owner = std::move(owner)](const Job& job) {
return job.owner == owner;
};
}
对于 std::unique_ptr、连接句柄或预编译策略等 move-only 资源,同样通过初始化捕获完成所有权转移:
#include <memory>
std::unique_ptr<int> threshold = std::make_unique<int>(5);
auto above_threshold = [limit = std::move(threshold)](int value) {
return value > *limit;
};
在成员函数中捕获当前对象时,[this] 保存裸指针(依赖原对象存活),而 C++17 的 [*this] 捕获当前对象副本(要求对象可复制且接受快照语义):
struct Scheduler {
int limit = 5;
auto pointer_filter() {
return [this](const Job& job) { return job.priority >= limit; };
}
auto snapshot_filter() const {
return [*this](const Job& job) { return job.priority >= limit; };
}
};
排查顺序
选择捕获方式前按以下顺序核对:
- 检查逃逸路径:闭包是否会返回、存入容器、跨线程或异步回调;会逃逸时禁止引用捕获局部对象或
[this]。 - 确认状态语义:需要创建时快照用值捕获或
[*this];需要反映后续变更再选引用捕获,并保证外部生命周期覆盖调用期。 - 处理所有权与移动:持有
std::unique_ptr等 move-only 资源或需转移大对象所有权时,使用初始化捕获std::move。 - 评估算法复制:STL 算法按值复制谓词与比较器,需确认捕获成员的复制成本与异常边界。
34.3 mutable lambda 与状态修改
默认非静态 lambda 的 operator() 是 const 成员函数,值捕获成员在函数体内只读;加上 mutable 会去掉该 const 限定,允许修改闭包自身的值捕获成员,但不会改变外部原变量。
| 写法 | operator() 限定 | 可修改目标 | 对外部原变量影响 |
|---|---|---|---|
[x] | const 成员函数 | 不可修改值捕获成员 | 无 |
[x] mutable | 非 const 成员函数 | 可修改闭包内的 x 副本 | 无(外部 x 保持不变) |
[&x] | const 成员函数 | 可经引用修改非 const 外部 x | 直接修改外部对象 |
下面的计数器展示了 mutable 修改的是闭包自有的 start 成员,外部 start 保持不变:
int start = 0;
auto next_id = [start]() mutable {
return ++start;
};
int a = next_id(); // 1
int b = next_id(); // 2
// 外部 start 仍为 0。
其等价的普通函数对象形态为去除 const 限定的成员函数:
struct NextIdClosure {
int start;
int operator()() {
return ++start;
}
};
mutable 不会把值捕获变成引用捕获;相反,引用捕获即便在默认 const 的 operator() 下也能修改外部非 const 对象,因为 const 修饰的是闭包对象本身而非被引用目标:
int external = 0;
auto bump_external = [&external] {
return ++external;
};
int x = bump_external(); // external 变为 1
将有状态的 mutable lambda 传入 STL 算法时,状态归属极易误判:
std::vector<int> values{1, 2, 3, 4};
auto first_two = [seen = 0](int) mutable {
return ++seen <= 2;
};
auto n = std::count_if(values.begin(), values.end(), first_two);
(void)n;
边界与误区
STL 算法通常按值复制谓词或比较器,算法内部推进的是内部副本的 seen,外部 first_two 的状态未必同步更新,并行算法还会引入更强的顺序与共享状态限制。排序比较器更禁止依赖调用次数,否则会破坏严格弱序前提。
mutable 适合构造局部生成器、一次性消费对象、缓存型函数对象与测试桩;若需要在算法中计数或采样,应将状态放在外层或改用显式循环,保持谓词与比较器的纯映射语义。
34.4 generic lambda
Generic lambda 是带有模板化调用运算符的闭包对象。C++14 起形参可使用 auto,C++20 起支持显式模板参数列表与 requires 约束;两种语法都会在闭包类型内部生成 operator() 函数模板。
auto less_by_deadline = [](const auto& lhs, const auto& rhs) {
return lhs.deadline < rhs.deadline;
};
其闭包类型自身并不是类模板,而是包含成员函数模板 operator() 的普通类,捕获状态仍属于闭包对象本身:
struct LessByDeadlineClosure {
template <class L, class R>
bool operator()(const L& lhs, const R& rhs) const {
return lhs.deadline < rhs.deadline;
}
};
不同参数写法决定了模板推导路径与错误暴露位置:
| 写法形式 | operator() 模板形态 | 错误暴露位置 | 适用场景 |
|---|---|---|---|
[](const auto& item) (C++14) | 独立推导形参 const T& | lambda 函数体内 | 只读访问元素、局部算法谓词 |
[](auto&& item) (C++14) | 转发引用 T&& | lambda 体内或转发下游 | 通用包装器与完美转发(需检查值类别) |
[]<class T>(const T& a, const T& b) requires ... (C++20) | 受约束同型模板 | 调用点接口处 | 要求同型比较或需前置概念诊断 |
C++20 的显式模板参数与 requires 约束可以把成员可用性要求写进调用接口:
auto less_by_deadline_checked = []<class T>(const T& lhs, const T& rhs)
requires requires { lhs.deadline < rhs.deadline; }
{
return lhs.deadline < rhs.deadline;
};
对于无需完美转发且只读访问元素的局部谓词,使用 const auto& 通常比 auto&& 更稳妥:
auto has_owner = [](const auto& item) {
return !item.owner.empty();
};
Generic lambda 传入 STL 算法时,算法仍只接收闭包对象,仅在模板实例化阶段检查对应的 operator()<...> 调用。若成员缺失或返回值不可转 bool,错误会沿 std::sort 等算法的实例化栈展开。
排查顺序
定位 generic lambda 与 STL 算法的实例化编译错误,按三步检查:
- 核对算法契约:确认算法期望的可调用签名(参数个数、引用绑定、返回值可转
bool)。 - 检查形参与返回:核查
const auto&、auto&&或显式模板形参能否匹配元素引用,以及返回类型是否合乎契约。 - 审查函数体表达式:检查实参类型是否具备被访问的成员或运算符,必要时用 C++20
requires将约束提前到接口处。
34.5 lambda 与 STL 算法
STL 算法将 lambda 视为策略对象(谓词、比较器、变换函数、投影函数或输出动作),真正的约束来自算法契约而非 lambda 语法本身。
以贯穿示例中的两种算法为例:std::count_if 要求输入 const Job& 且返回可转 bool 的一元谓词,重点核对捕获状态与生命周期:
auto urgent_count = std::count_if(jobs.begin(), jobs.end(), urgent_for_owner);
std::stable_sort 则要求二元比较器提供稳定的严格弱序,无捕获 lambda 因无外部可变状态而最为稳妥:
std::stable_sort(jobs.begin(), jobs.end(), [](const Job& lhs, const Job& rhs) {
return std::tie(lhs.deadline, lhs.priority) <
std::tie(rhs.deadline, rhs.priority);
});
比较器若需读取配置参数(如排序方向、阈值、区域配置或字段规则),应值捕获不可变快照;若引用捕获外部可变状态且排序中途该状态发生变化,同一对元素前后比较结果可能矛盾,直接破坏排序前提:
bool earlier_first = true;
auto by_deadline = [earlier_first](const Job& lhs, const Job& rhs) {
if (earlier_first) {
return lhs.deadline < rhs.deadline;
}
return rhs.deadline < lhs.deadline;
};
当 lambda 捕获了容器内部元素的引用并作用于同一容器时,需同步检查容器重排与扩容引发的失效风险:
Job& pivot = jobs.front();
auto near_pivot = [&pivot](const Job& job) {
return job.deadline < pivot.deadline + 60;
};
// 如果后续对 jobs 排序或扩容,pivot 引用和它表达的语义都需要重新审查。
边界与误区
排序、重排、erase-remove 以及 vector 扩容都会移动元素或改变对象地址。若闭包保存了容器内某元素的引用(如 &pivot),对同一容器执行修改操作极易造成引用悬垂或比较基准漂移。
不同 STL 算法家族对 lambda 的契约重点不同:
| STL 算法族 | 契约要求 | Lambda 审查重点 |
|---|---|---|
find_if / count_if / remove_if | 一元谓词(返回可转 bool) | 谓词纯度、捕获生命周期、避免依赖调用次数 |
sort / stable_sort / binary_search | 二元严格弱序比较器 | 无状态或不可变快照、匹配既有排序前提 |
transform | 一元/二元变换函数 | 形参与输出区间类型匹配 |
for_each | 一元输出/操作动作 | 明确副作用对象的所有权与生命周期 |
核心判断
审查传入 STL 算法的 lambda 需依次确认 6 项:
- 算法角色:明确需要一元谓词、二元比较器、变换函数还是输出动作。
- 签名绑定:确认形参能绑定元素引用,返回值符合算法要求。
- 捕获性质:区分捕获对象是不可变快照、共享状态还是外部引用。
- 逃逸与复制:确认闭包是否会被复制、保存、延迟调用或跨线程执行。
- 结果稳定性:确保谓词与比较器不依赖调用次数、可变全局状态或正在被修改的元素位置。
- 异常与成本:核算捕获成员的复制、移动、析构成本及异常边界。
工程上决定采用 lambda、显式函数对象还是 std::function,不取决于写法长短,而取决于复用边界与类型擦除成本:
- Lambda:适合局部、一次性、捕获少且需要零类型擦除开销的策略。
- 显式函数对象:适合需要跨处复用、命名领域语义、维护复杂不变量或单独单元测试的策略。
std::function:适合运行时统一保存异构可调用对象,但会引入类型擦除与潜在堆分配开销(下一章展开)。
最小自检任务
阅读下面代码,判断 value_pred、ref_pred、next_id 三个闭包的成员状态、捕获边界与执行结果,并判断外部变量修改会影响哪条调用路径。
#include <algorithm>
#include <vector>
int main() {
std::vector<int> values{4, 5, 6};
int limit = 3;
auto value_pred = [limit](int value) {
return value > limit;
};
auto ref_pred = [&limit](int value) {
return value > limit;
};
limit = 5;
auto value_count = std::count_if(values.begin(), values.end(), value_pred);
auto ref_count = std::count_if(values.begin(), values.end(), ref_pred);
auto next_id = [id = 0]() mutable {
return ++id;
};
int a = next_id();
int b = next_id();
auto copied = next_id;
int c = copied();
int d = next_id();
(void)value_count;
(void)ref_count;
(void)a;
(void)b;
(void)c;
(void)d;
}
本章知识点总结
- 闭包对象与类型
lambda 求值生成带唯一未命名闭包类型的对象;无捕获 lambda 在签名匹配时可转换为函数指针。
- 值捕获与复制语义
值捕获将创建时快照存为闭包成员并随闭包复制,传入 STL 算法时需核算复制成本与异常边界。
- 引用捕获与生命周期
引用捕获在调用时读取外部对象,外部变量及容器元素(防重排/扩容失效)的生命周期必须覆盖闭包调用期。
- 初始化捕获与 this
C++14 初始化捕获可转移
std::unique_ptr等 move-only 所有权;[this]捕获裸指针而 C++17[*this]捕获当前对象快照。 - mutable 与状态归属
mutable仅取消operator()的const限定以允许修改值捕获成员副本;STL 算法通常复制谓词,状态变更仅作用于内部副本。 - generic lambda
C++14
auto形参或 C++20 显式模板参数会生成成员函数模板operator(),类型不匹配在算法模板实例化阶段暴露,可用requires前置约束。 - 算法契约与选型
排序比较器须维持严格弱序且不依赖调用次数;局部策略用 lambda,复杂复用或不变量用显式函数对象,异构运行时存储用
std::function。