Lambda 表达式
Lambda 表达式是现代 C++ 函数式编程风格的基石。它让你能够在需要的地方就地定义匿名函数对象,避免编写大量只使用一次的具名函数或函数对象类。从 C++11 引入以来,Lambda 在每个标准版本中都得到了增强,已成为日常 C++ 编程中最常用的特性之一。
Lambda 基础语法
Lambda 表达式的完整语法结构如下:
[捕获列表](参数列表) -> 返回类型 { 函数体 }
各部分的含义:
- 捕获列表
[]— 指定 Lambda 如何访问外部作用域中的变量(必须存在,即使为空) - 参数列表
()— 与普通函数参数相同(无参数时可省略括号) - 返回类型
->— 通常可省略,编译器自动推导 - 函数体
{}— Lambda 执行的代码
从最简单到逐渐复杂的例子:
#include <iostream>
#include <vector>
#include <algorithm>
int main() {
// 最简形式:无捕获、无参数
auto hello = [] { std::cout << "Hello Lambda!\n"; };
hello(); // 输出: Hello Lambda!
// 带参数
auto add = [](int x, int y) { return x + y; };
std::cout << add(3, 4) << "\n"; // 输出: 7
// 显式返回类型(通常不需要,但有歧义时可用)
auto divide = [](double a, double b) -> double {
if (b == 0.0) return 0.0; // 避免除零
return a / b;
};
std::cout << divide(10.0, 3.0) << "\n"; // 输出: 3.33333
// 直接作为算法参数(最常见用法)
std::vector<int> nums{5, 2, 8, 1, 9, 3};
std::sort(nums.begin(), nums.end(), [](int a, int b) {
return a > b; // 降序排列
});
// nums: {9, 8, 5, 3, 2, 1}
}
何时需要显式返回类型?当函数体有多个 return 语句且返回不同类型时,编译器可能无法推导,此时需要用 -> 显式指定。日常使用中,90% 以上的 Lambda 都可以省略返回类型。
捕获语义
捕获列表控制 Lambda 如何访问定义它的作用域中的局部变量。这是 Lambda 与普通函数最大的区别 — Lambda 可以形成闭包(closure)。
| 语法 | 含义 | 说明 |
|---|---|---|
[] |
不捕获 | Lambda 无法访问外部局部变量 |
[=] |
按值捕获所有 | 复制所有被引用的外部变量 |
[&] |
按引用捕获所有 | 引用所有被引用的外部变量 |
[x] |
按值捕获 x | 仅复制变量 x |
[&x] |
按引用捕获 x | 仅引用变量 x |
[=, &x] |
混合捕获 | 默认按值,但 x 按引用 |
[&, x] |
混合捕获 | 默认按引用,但 x 按值 |
[x = std::move(obj)] |
初始化捕获 (C++14) | 将 obj 移动到捕获变量 x 中 |
[this] |
捕获 this 指针 | 访问当前对象的成员 |
[*this] |
捕获 this 的副本 (C++17) | 复制整个对象,安全但有开销 |
捕获方式的使用示例:
#include <iostream>
#include <vector>
#include <algorithm>
#include <memory>
int main() {
int threshold = 10;
std::string prefix = "Result: ";
std::vector<int> data{3, 14, 15, 9, 26, 5, 35};
// 按值捕获 threshold
auto count = std::count_if(data.begin(), data.end(),
[threshold](int x) { return x > threshold; });
std::cout << "大于 " << threshold << " 的个数: " << count << "\n";
// 按引用捕获 — 可以修改外部变量
int sum = 0;
std::for_each(data.begin(), data.end(), [&sum](int x) {
sum += x;
});
std::cout << "总和: " << sum << "\n";
// 混合捕获:prefix 按值,sum 按引用
std::for_each(data.begin(), data.end(), [prefix, &sum](int x) {
std::cout << prefix << x << "\n";
});
// 初始化捕获(C++14):移动不可复制的对象
auto ptr = std::make_unique<int>(42);
auto task = [p = std::move(ptr)]() {
std::cout << "Value: " << *p << "\n";
};
// ptr 现在是 nullptr,所有权已转移到 lambda 中
task(); // 输出: Value: 42
}
引用捕获的生命周期陷阱!如果 Lambda 的生存期超过了被引用变量的生存期,将导致悬垂引用(dangling reference)。典型场景:将捕获了局部变量引用的 Lambda 存储到容器中、返回给调用者、或传递给异步任务。此时应使用按值捕获或初始化捕获。
// 危险示例 — 不要这样做!
#include <functional>
std::function<int()> make_counter() {
int count = 0;
// 错误:返回后 count 已销毁,引用悬垂
// return [&count]() { return ++count; };
// 正确:按值捕获(配合 mutable,稍后讲解)
return [count]() mutable { return ++count; };
}
// [this] vs [*this] 示例
struct Widget {
int value = 10;
auto get_printer() {
// [this] 只捕获指针 — 如果 Widget 对象被销毁,this 悬垂
// [*this] 复制整个对象 — 安全但有拷贝开销
return [*this]() { std::cout << value << "\n"; };
}
};
泛型 Lambda(auto 参数)
C++14 允许在 Lambda 参数中使用 auto,使其成为泛型的(类似函数模板)。C++20 更进一步,支持模板 Lambda 语法。
#include <iostream>
#include <vector>
#include <string>
#include <numeric>
int main() {
// C++14 泛型 Lambda — 参数使用 auto
auto print = [](const auto& x) {
std::cout << x << "\n";
};
print(42); // int
print(3.14); // double
print("hello"); // const char*
print(std::string{"world"}); // std::string
// 泛型 Lambda 实现通用比较器
auto less_by_size = [](const auto& a, const auto& b) {
return a.size() < b.size();
};
std::vector<std::string> words{"lambda", "is", "powerful", "in", "cpp"};
std::sort(words.begin(), words.end(), less_by_size);
// words: {"is", "in", "cpp", "lambda", "powerful"}
// C++20 模板 Lambda — 可以指定类型约束
auto sum_vec = []<typename T>(const std::vector<T>& v) {
return std::accumulate(v.begin(), v.end(), T{});
};
std::vector<int> ints{1, 2, 3, 4, 5};
std::vector<double> dbls{1.1, 2.2, 3.3};
std::cout << sum_vec(ints) << "\n"; // 15
std::cout << sum_vec(dbls) << "\n"; // 6.6
// C++20 模板 Lambda + Concepts 约束
auto print_container = []<typename T>(const std::vector<T>& v)
requires std::is_arithmetic_v<T>
{
for (const auto& elem : v) {
std::cout << elem << " ";
}
std::cout << "\n";
};
print_container(ints); // OK
// print_container(words); // 编译错误:string 不是 arithmetic 类型
}
auto vs 模板 Lambda:如何选择?如果只需要"接受任意类型",auto 参数足够简洁。当你需要在函数体中引用参数的类型(如创建同类型变量),或需要约束多个参数为同一类型时,使用 C++20 模板 Lambda 语法更清晰。
mutable Lambda
默认情况下,按值捕获的变量在 Lambda 内部是 const 的 — 你不能修改它们的副本。如果需要修改捕获的副本,必须加上 mutable 关键字。
#include <iostream>
#include <functional>
int main() {
int counter = 0;
// 编译错误:不能修改按值捕获的变量
// auto inc = [counter]() { return ++counter; };
// 正确:mutable 允许修改捕获的副本
auto inc = [counter]() mutable { return ++counter; };
std::cout << inc() << "\n"; // 1
std::cout << inc() << "\n"; // 2
std::cout << inc() << "\n"; // 3
// 注意:外部的 counter 并未改变!
std::cout << "外部 counter = " << counter << "\n"; // 0
}
// 实用案例:生成唯一 ID
auto make_id_generator(int start = 0) {
return [id = start]() mutable { return id++; };
}
// 使用
void demo() {
auto gen = make_id_generator(100);
std::cout << gen() << "\n"; // 100
std::cout << gen() << "\n"; // 101
std::cout << gen() << "\n"; // 102
}
mutable 的本质:Lambda 在底层是一个匿名类,捕获的变量是其成员。默认情况下 operator() 是 const 成员函数,所以不能修改成员。mutable 将其改为非 const 成员函数。
立即调用(IIFE)
IIFE(Immediately Invoked Function Expression,立即调用函数表达式)是一种将 Lambda 定义后立即调用的模式。它主要用于复杂的 const 变量初始化。
#include <iostream>
#include <string>
#include <vector>
enum class LogLevel { Debug, Info, Warning, Error };
int main() {
// 问题:复杂初始化逻辑无法直接用于 const 变量
// const std::string msg = ???; // 需要 if-else 逻辑
LogLevel level = LogLevel::Warning;
// IIFE 解决:Lambda 立即调用,返回值初始化 const 变量
const std::string msg = [&]() -> std::string {
switch (level) {
case LogLevel::Debug: return "[DEBUG]";
case LogLevel::Info: return "[INFO]";
case LogLevel::Warning: return "[WARN]";
case LogLevel::Error: return "[ERROR]";
}
return "[UNKNOWN]";
}(); // 注意末尾的 () — 立即调用!
std::cout << msg << " Something happened\n";
// 另一个场景:需要多步计算的 const 初始化
const std::vector<int> fibonacci = [&]() {
std::vector<int> fib{0, 1};
for (int i = 2; i < 20; ++i) {
fib.push_back(fib[i-1] + fib[i-2]);
}
return fib;
}();
// fibonacci 是 const 的,初始化后不能修改
// IIFE 初始化互斥资源
const auto config = [&]() {
// 可以在这里做文件读取、解析、验证等复杂操作
struct Config { int port; std::string host; };
return Config{8080, "localhost"};
}();
}
为什么用 IIFE?三个好处:(1) 保持变量 const,表达不变意图;(2) 限制临时变量的作用域,不污染外部命名空间;(3) 让初始化逻辑内聚,更易阅读和维护。
Lambda 与 std::function
每个 Lambda 表达式都有一个唯一的匿名类型(即使代码完全相同的两个 Lambda 类型也不同)。当需要存储、传递多种不同 Lambda 时,std::function 提供了类型擦除的容器。
#include <iostream>
#include <functional>
#include <vector>
#include <map>
int main() {
// auto 保留 Lambda 的精确类型 — 零开销
auto fast_add = [](int a, int b) { return a + b; };
// std::function 擦除类型 — 有堆分配和间接调用开销
std::function<int(int, int)> flexible_op = fast_add;
flexible_op = [](int a, int b) { return a * b; }; // 可以重新赋值
// 典型用途:存储回调函数的容器
std::vector<std::function<void()>> callbacks;
callbacks.push_back([] { std::cout << "Callback 1\n"; });
callbacks.push_back([] { std::cout << "Callback 2\n"; });
for (auto& cb : callbacks) cb();
// 典型用途:命令模式 / 事件分发
std::map<std::string, std::function<double(double, double)>> ops;
ops["add"] = [](double a, double b) { return a + b; };
ops["sub"] = [](double a, double b) { return a - b; };
ops["mul"] = [](double a, double b) { return a * b; };
ops["div"] = [](double a, double b) { return b != 0 ? a / b : 0; };
std::cout << ops["add"](10, 3) << "\n"; // 13
std::cout << ops["mul"](4, 5) << "\n"; // 20
}
std::function 的性能代价:它内部可能触发堆分配(小对象优化可能避免),并引入虚函数调用般的间接开销。规则很简单:局部使用 Lambda 时优先用 auto;只有当需要运行时多态(如存入容器、作为类成员)时才用 std::function。
// 函数参数:模板 vs std::function
// 推荐:模板参数 — 编译器可内联 Lambda,零开销
template<typename Func>
void apply_twice(int x, Func f) {
std::cout << f(f(x)) << "\n";
}
// 不推荐(除非必要):std::function 参数 — 有间接调用开销
void apply_twice_slow(int x, std::function<int(int)> f) {
std::cout << f(f(x)) << "\n";
}
void demo() {
apply_twice(3, [](int n) { return n * 2; }); // 12,零开销
apply_twice_slow(3, [](int n) { return n * 2; }); // 12,有开销
}
实际应用场景
场景一:作为算法回调
#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
int main() {
std::vector<int> scores{85, 92, 78, 95, 68, 88, 73, 91};
// 统计及格人数
auto pass_count = std::count_if(scores.begin(), scores.end(),
[](int s) { return s >= 80; });
std::cout << "及格人数: " << pass_count << "\n";
// 找到最接近 90 分的成绩
auto closest = *std::min_element(scores.begin(), scores.end(),
[](int a, int b) {
return std::abs(a - 90) < std::abs(b - 90);
});
std::cout << "最接近90的成绩: " << closest << "\n";
// 将所有成绩加 5 分(不超过 100)
std::transform(scores.begin(), scores.end(), scores.begin(),
[](int s) { return std::min(s + 5, 100); });
}
场景二:自定义排序比较器
#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <set>
struct Student {
std::string name;
int score;
int age;
};
int main() {
std::vector<Student> students{
{"Alice", 92, 20},
{"Bob", 85, 22},
{"Carol", 92, 21},
{"Dave", 78, 20}
};
// 多条件排序:先按分数降序,分数相同按年龄升序
std::sort(students.begin(), students.end(),
[](const Student& a, const Student& b) {
if (a.score != b.score) return a.score > b.score;
return a.age < b.age;
});
for (const auto& s : students) {
std::cout << s.name << " " << s.score << " " << s.age << "\n";
}
// Lambda 作为 std::set 的比较器
auto cmp = [](const std::string& a, const std::string& b) {
return a.size() < b.size(); // 按长度排序
};
std::set<std::string, decltype(cmp)> words(cmp);
words.insert("hello");
words.insert("hi");
words.insert("hey");
// words 按字符串长度排列
}
场景三:事件处理与回调
#include <iostream>
#include <functional>
#include <vector>
#include <string>
// 简单事件系统
class EventBus {
public:
using Handler = std::function<void(const std::string&)>;
void subscribe(const std::string& event, Handler handler) {
handlers_[event].push_back(std::move(handler));
}
void emit(const std::string& event, const std::string& data) {
if (auto it = handlers_.find(event); it != handlers_.end()) {
for (auto& handler : it->second) {
handler(data);
}
}
}
private:
std::map<std::string, std::vector<Handler>> handlers_;
};
int main() {
EventBus bus;
// 使用 Lambda 注册事件处理器
bus.subscribe("user_login", [](const std::string& user) {
std::cout << "欢迎回来, " << user << "!\n";
});
bus.subscribe("user_login", [](const std::string& user) {
std::cout << "记录登录日志: " << user << "\n";
});
int error_count = 0;
bus.subscribe("error", [&error_count](const std::string& msg) {
++error_count;
std::cout << "错误 #" << error_count << ": " << msg << "\n";
});
bus.emit("user_login", "Alice");
bus.emit("error", "连接超时");
bus.emit("error", "文件未找到");
}
本章小结
- 基础语法:
[captures](params) -> ret { body },返回类型通常可省略 - 捕获语义:按值
[x]安全但不能修改;按引用[&x]高效但注意生命周期;初始化捕获[x = expr]支持移动 - 泛型 Lambda:C++14 用
auto参数,C++20 用模板语法[]<typename T> - mutable:按值捕获默认 const,需修改副本时加
mutable - IIFE:
[&]{ ... }()用于复杂 const 初始化 - std::function:需要类型擦除时使用,局部 Lambda 优先用
auto - 最佳实践:优先按值捕获,显式列出捕获变量(避免
[=]/[&]隐式捕获)