Lambda 显式模板参数
什么是 Lambda 显式模板参数
C++14 引入了泛型 lambda(参数用 auto),但这种方式没办法直接获取模板参数的类型名、不能约束多个参数为同一类型、不能用非类型模板参数。C++20 允许 lambda 使用和普通函数模板一样的模板参数列表语法,写在捕获列表 [] 后面的 <> 中。
cpp
// C++14 泛型 lambda
auto gen = [](auto a, auto b) { return a + b; };
// C++20 模板 lambda
auto tmpl = []<typename T>(T a, T b) { return a + b; };模板 lambda 的关键优势是可以直接使用模板参数名 T,约束参数类型关系,或者使用非类型模板参数。
泛型 Lambda vs 模板 Lambda
| 特性 | 泛型 Lambda(C++14) | 模板 Lambda(C++20) |
|---|---|---|
| 语法 | [](auto a, auto b) | []<typename T>(T a, T b) |
| 多个参数同一类型 | 不能强制 | 可以(用同一个 T) |
| 访问类型名 | 需要 decltype | 直接用 T |
| 非类型模板参数 | 不支持 | 支持 |
| 约束(concepts) | 需要 std::enable_if 等 | 直接用 requires 或受约束模板参数 |
| 完美转发 | decltype(arg) 繁琐 | std::forward<T>(arg) 简洁 |
| 容器元素类型推导 | 需要辅助 traits | 直接 vector<T> |
基本示例
cpp
#include <iostream>
#include <vector>
#include <string>
#include <type_traits>
#include <concepts>
#include <array>
#include <numeric>
// ============================
// 示例1:强制参数类型相同
// ============================
void same_type_demo() {
// C++14:两个参数可以是不同类型
auto add_generic = [](auto a, auto b) { return a + b; };
// C++20:强制两个参数类型相同
auto add_same = []<typename T>(T a, T b) { return a + b; };
std::cout << add_generic(1, 2.5) << std::endl; // 可以:int + double
std::cout << add_same(1, 2) << std::endl; // 可以:int + int
std::cout << add_same(1.5, 2.5) << std::endl; // 可以:double + double
// add_same(1, 2.5); // 错误:T 推导冲突(int vs double)
}
// ============================
// 示例2:直接访问模板参数类型
// ============================
void type_access_demo() {
// C++14:需要 decltype 获取类型
auto old_way = [](auto x) {
using T = decltype(x);
if constexpr (std::is_integral_v<T>) {
std::cout << x << " 是整数类型" << std::endl;
} else {
std::cout << x << " 不是整数类型" << std::endl;
}
};
// C++20:直接使用 T
auto new_way = []<typename T>(T x) {
if constexpr (std::is_integral_v<T>) {
std::cout << x << " 是整数类型" << std::endl;
} else {
std::cout << x << " 不是整数类型" << std::endl;
}
};
new_way(42); // 42 是整数类型
new_way(3.14); // 3.14 不是整数类型
new_way("hello"); // hello 不是整数类型
}
// ============================
// 示例3:约束容器类型
// ============================
void container_demo() {
// C++20:只接受 std::vector<T>
auto print_vector = []<typename T>(const std::vector<T>& vec) {
std::cout << "vector<" << typeid(T).name() << ">: ";
for (const auto& v : vec) {
std::cout << v << " ";
}
std::cout << std::endl;
};
std::vector<int> vi = {1, 2, 3};
std::vector<std::string> vs = {"hello", "world"};
print_vector(vi); // 正确
print_vector(vs); // 正确
// std::deque<int> di = {1, 2, 3};
// print_vector(di); // 错误:不是 vector
}
// ============================
// 示例4:非类型模板参数
// ============================
void nttp_demo() {
// 非类型模板参数——只有模板 lambda 能做到
auto make_array = []<typename T, std::size_t N>(const T(&arr)[N]) {
// 从 C 数组创建 std::array
std::array<T, N> result;
for (std::size_t i = 0; i < N; ++i) {
result[i] = arr[i];
}
return result;
};
int raw[] = {10, 20, 30, 40};
auto arr = make_array(raw); // std::array<int, 4>
std::cout << "array 大小: " << arr.size() << std::endl;
for (int v : arr) {
std::cout << v << " ";
}
std::cout << std::endl;
}
// ============================
// 示例5:完美转发
// ============================
void log_value(int& x) { std::cout << "左值引用: " << x << std::endl; }
void log_value(int&& x) { std::cout << "右值引用: " << x << std::endl; }
void forwarding_demo() {
// C++14 完美转发——decltype 比较繁琐
auto forward_old = [](auto&& arg) {
log_value(std::forward<decltype(arg)>(arg));
};
// C++20 完美转发——直接用 T
auto forward_new = []<typename T>(T&& arg) {
log_value(std::forward<T>(arg));
};
int x = 42;
forward_new(x); // 左值引用
forward_new(100); // 右值引用
forward_new(std::move(x)); // 右值引用
}
// ============================
// 示例6:结合 Concepts 约束
// ============================
void concepts_demo() {
// 用 concept 约束模板参数
auto add_integral = []<std::integral T>(T a, T b) {
return a + b;
};
// 用 requires 子句约束
auto multiply = []<typename T>(T a, T b) requires std::is_arithmetic_v<T> {
return a * b;
};
std::cout << add_integral(10, 20) << std::endl; // 30
// add_integral(1.5, 2.5); // 错误:double 不满足 std::integral
std::cout << multiply(3, 4) << std::endl; // 12
std::cout << multiply(2.5, 3.0) << std::endl; // 7.5
// multiply(std::string("a"), std::string("b")); // 错误:string 不是 arithmetic
}
// ============================
// 示例7:可变参数模板 Lambda
// ============================
void variadic_demo() {
// 可变参数模板 lambda
auto print_all = []<typename... Args>(Args&&... args) {
((std::cout << args << " "), ...);
std::cout << std::endl;
};
print_all(1, 2.5, "hello", 'c');
// 计算参数个数
auto count_args = []<typename... Args>(Args&&...) {
return sizeof...(Args);
};
std::cout << "参数个数: " << count_args(1, 2, 3, 4, 5) << std::endl;
}
int main() {
std::cout << "=== 同类型约束 ===" << std::endl;
same_type_demo();
std::cout << "\n=== 类型访问 ===" << std::endl;
type_access_demo();
std::cout << "\n=== 容器约束 ===" << std::endl;
container_demo();
std::cout << "\n=== 非类型模板参数 ===" << std::endl;
nttp_demo();
std::cout << "\n=== 完美转发 ===" << std::endl;
forwarding_demo();
std::cout << "\n=== Concepts 约束 ===" << std::endl;
concepts_demo();
std::cout << "\n=== 可变参数 ===" << std::endl;
variadic_demo();
return 0;
}适用场景
- 需要强制多个参数为同一类型
- 需要在 lambda 内部使用模板参数类型名(避免 decltype)
- 需要非类型模板参数(如数组大小 N)
- 完美转发更简洁
- 结合 Concepts 约束 lambda 参数
- 需要约束 lambda 只接受特定模板的实例化(如
vector<T>)
常见问题
模板 lambda 和泛型 lambda 可以混用吗?
可以。同一个 lambda 可以同时有显式模板参数和 auto 参数。显式模板参数写在 <> 中,auto 参数是额外的隐式模板参数。
cpp
auto mixed = []<typename T>(T a, auto b) { /* ... */ };模板 lambda 可以显式指定模板参数调用吗?
不能直接这样做(lambda 没有名字可以指定模板参数)。但可以通过 operator() 显式调用:
cpp
auto fn = []<typename T>(T x) { return x; };
fn.operator()<int>(42); // 显式指定 T = int模板 lambda 的闭包类型是什么样的?
编译器生成一个匿名类,其 operator() 是一个成员函数模板。比如 []<typename T>(T x) { return x; } 等价于一个类,其 operator() 是 template<typename T> auto operator()(T x) const。
注意事项
- 模板参数列表写在
[]后面的<>中 - 模板 lambda 一定是泛型 lambda
- 可以结合 concepts 和 requires 进行约束
- 显式指定模板参数需要用
.operator()<Type>(...)语法 - 模板 lambda 可以有默认模板参数
编译器支持情况
| 编译器 | 最低支持版本 |
|---|---|
| GCC | 8.0 |
| Clang | 9.0 |
| MSVC | 19.22 (VS 2019 16.2) |
总结
C++20 的模板 lambda 允许在 lambda 中使用和函数模板一样的显式模板参数列表。和 C++14 的泛型 lambda(auto 参数)相比,模板 lambda 可以直接使用类型名、强制多个参数类型相同、使用非类型模板参数、更简洁地完美转发,还能结合 Concepts 进行约束。它让 lambda 具备了和普通函数模板同等的表达能力,在很多场景下可以替代单独定义的函数模板。