Skip to main content

Chapter 34: Lambda Expressions

核心问题与阅读主线

本章导读5 个核心小节 · 附自检与总结

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; };
}
};

排查顺序

选择捕获方式前按以下顺序核对:

  1. 检查逃逸路径:闭包是否会返回、存入容器、跨线程或异步回调;会逃逸时禁止引用捕获局部对象或 [this]。
  2. 确认状态语义:需要创建时快照用值捕获或 [*this];需要反映后续变更再选引用捕获,并保证外部生命周期覆盖调用期。
  3. 处理所有权与移动:持有 std::unique_ptr 等 move-only 资源或需转移大对象所有权时,使用初始化捕获 std::move。
  4. 评估算法复制: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 算法的实例化编译错误,按三步检查:

  1. 核对算法契约:确认算法期望的可调用签名(参数个数、引用绑定、返回值可转 bool)。
  2. 检查形参与返回:核查 const auto&、auto&& 或显式模板形参能否匹配元素引用,以及返回类型是否合乎契约。
  3. 审查函数体表达式:检查实参类型是否具备被访问的成员或运算符,必要时用 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 项:

  1. 算法角色:明确需要一元谓词、二元比较器、变换函数还是输出动作。
  2. 签名绑定:确认形参能绑定元素引用,返回值符合算法要求。
  3. 捕获性质:区分捕获对象是不可变快照、共享状态还是外部引用。
  4. 逃逸与复制:确认闭包是否会被复制、保存、延迟调用或跨线程执行。
  5. 结果稳定性:确保谓词与比较器不依赖调用次数、可变全局状态或正在被修改的元素位置。
  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。