10. 泛型 Lambda：C++14 引入，auto 参数类型推导
好，咱们来聊聊泛型 Lambda。这东西是 C++14 引入的，说白了就是让 Lambda 也能像模板函数一样，接受任意类型的参数。你想想看，以前写 Lambda，参数类型得写死，int 就是 int，double 就是 double。现在好了，一个 auto 搞定一切。
我记得第一次看到这个特性时，心里还挺激动的。因为我在项目中经常要写一些通用的回调函数，比如排序比较器、事件处理器之类的。以前得写一堆重载，或者搞个模板类。有了泛型 Lambda，代码瞬间清爽多了。
10.1 什么是泛型 Lambda？
泛型 Lambda，本质上就是参数类型被推导为模板参数的 Lambda 表达式。编译器会为每个 auto 参数生成一个模板参数。嗯，这里要注意，它并不是运行时多态，而是编译期多态——说白了就是编译器帮你生成了多个版本的函数。
看个最简单的例子：
auto add = [](auto a, auto b) {
return a + b;
};
int x = add(3, 4); // int 版本
double y = add(2.5, 3.7); // double 版本
std::string s = add(std::string("Hello "), std::string("World")); // string 版本你看，同一个 Lambda，传 int 就生成 int 版本的代码，传 double 就生成 double 版本的。编译器在背后默默做了这些事，你只管用就行。
核心要点：泛型 Lambda 的参数类型推导发生在编译期，每个不同的参数类型组合都会实例化出一个独立的函数体。这跟模板函数是一个道理。
10.2 语法与使用方式
语法其实很简单，就是把参数类型写成 auto。可以有一个 auto 参数，也可以有多个。甚至还可以混搭——一部分参数用具体类型，一部分用 auto。
// 单个 auto 参数
auto print = [](auto value) {
std::cout << value << std::endl;
};
// 多个 auto 参数
auto multiply = [](auto a, auto b) {
return a * b;
};
// 混搭：第一个参数固定为 int，第二个参数自动推导
auto mixed = [](int x, auto y) {
return x + y;
};我个人习惯把泛型 Lambda 用在 STL 算法里，尤其是那些需要自定义操作的场景。比如：
std::vector<int> numbers = {3, 1, 4, 1, 5, 9};
std::vector<std::string> words = {"apple", "banana", "cherry"};
// 同一个 Lambda 可以同时用于 int 和 string 的打印
auto print_each = [](const auto& item) {
std::cout << item << " ";
};
std::for_each(numbers.begin(), numbers.end(), print_each);
std::for_each(words.begin(), words.end(), print_each);你看，一个 Lambda 搞定两种类型的遍历。这在以前得写两个不同的函数或者模板函数才能做到。
10.3 类型推导的细节
这里有个坑，我得提醒你。auto 参数的类型推导规则跟模板参数推导完全一致。这意味着：
auto会推导为值类型（会拷贝）auto&会推导为左值引用const auto&会推导为 const 左值引用auto&&会推导为转发引用（万能引用）
我曾经在项目中遇到过一个问题：用 auto 接收一个大对象，结果每次调用都拷贝一次，性能直接崩了。后来改成 const auto& 才解决。所以，写泛型 Lambda 时，引用语义一定要想清楚。
// 值传递：会拷贝
auto by_value = [](auto x) {
// x 是副本
};
// 左值引用：不会拷贝，但只能接收左值
auto by_ref = [](auto& x) {
// x 是引用
};
// const 左值引用：安全，不会拷贝，可接收左值和右值
auto by_const_ref = [](const auto& x) {
// x 是 const 引用
};
// 转发引用：可以接收左值和右值，保持值类别
auto forward_ref = [](auto&& x) {
// x 是万能引用
};小技巧：如果你不确定该用哪种，默认用 const auto& 最安全。只有当你明确需要修改参数或需要移动语义时，才考虑其他形式。
10.4 泛型 Lambda 与模板的对比
你可能会问：这跟写个模板函数有啥区别？区别大了去了。泛型 Lambda 可以就地定义，不需要单独声明一个模板函数。而且它可以捕获上下文中的变量，这是普通模板函数做不到的。
| 特性 | 泛型 Lambda | 模板函数 |
|---|---|---|
| 定义位置 | 就地定义，在表达式内部 | 需要单独声明 |
| 捕获变量 | 支持捕获（按值、按引用） | 不支持捕获 |
| 类型推导 | auto 参数自动推导 | 模板参数显式或隐式推导 |
| 可读性 | 简洁，适合短小操作 | 适合复杂逻辑 |
| 复用性 | 通常一次使用 | 可多次复用 |
说白了，泛型 Lambda 更适合那些「一次性」的通用操作。比如在算法里传个比较器、转换器之类的。而模板函数更适合那些需要多次调用、逻辑复杂的场景。
10.5 实际应用场景
我在项目中用得最多的场景有两个：
场景一：通用的比较器
// 按任意类型的某个字段排序
auto sort_by_field = [](auto& container, auto field_getter) {
std::sort(container.begin(), container.end(),
[&field_getter](const auto& a, const auto& b) {
return field_getter(a) < field_getter(b);
});
};
// 使用
std::vector<Person> people = {...};
sort_by_field(people, [](const Person& p) { return p.age; });
sort_by_field(people, [](const Person& p) { return p.name; });场景二：通用的访问者模式
// 访问 std::variant 的通用 Lambda
auto visitor = [](const auto& value) {
using T = std::decay_t<decltype(value)>;
if constexpr (std::is_same_v<T, int>) {
std::cout << "int: " << value << std::endl;
} else if constexpr (std::is_same_v<T, double>) {
std::cout << "double: " << value << std::endl;
} else if constexpr (std::is_same_v<T, std::string>) {
std::cout << "string: " << value << std::endl;
}
};
std::variant<int, double, std::string> v = 42;
std::visit(visitor, v);你看，配合 if constexpr，泛型 Lambda 可以做到类型感知的分支处理。这在处理 variant、any 等类型时特别有用。
10.6 避坑指南
我曾经踩过的坑：
- 不要过度使用 auto 参数：如果参数类型只有少数几种，显式写出类型反而更清晰。泛型 Lambda 适合「真的不知道类型」的场景。
- 注意代码膨胀：每个不同的参数类型组合都会生成一份独立的代码。如果类型组合很多，可执行文件会变大。
- 小心引用折叠：使用
auto&&时，引用折叠规则可能导致意想不到的行为。建议在需要完美转发时使用decltype配合std::forward。
10.7 知识体系总览
下面这张图帮你理清泛型 Lambda 的核心逻辑：
10.8 总结
泛型 Lambda 是 C++14 给我们的一个很实用的工具。它让 Lambda 表达式从「固定类型」进化到了「通用类型」，大大提升了代码的复用性和灵活性。
我个人觉得，掌握泛型 Lambda 的关键在于理解它的类型推导机制。你只要记住：auto 参数就是模板参数，推导规则跟模板一样。然后根据场景选择合适的引用语义，就能写出既通用又高效的代码。
嗯，最后再啰嗦一句：别为了炫技而滥用。如果类型是固定的，老老实实写具体类型反而更清晰。泛型 Lambda 的价值在于「真的需要通用」的时候。
公众号:蓝海资料掘金营，微信deep3321