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 可以有默认模板参数

编译器支持情况 ​

编译器最低支持版本
GCC8.0
Clang9.0
MSVC19.22 (VS 2019 16.2)

总结 ​

C++20 的模板 lambda 允许在 lambda 中使用和函数模板一样的显式模板参数列表。和 C++14 的泛型 lambda(auto 参数)相比,模板 lambda 可以直接使用类型名、强制多个参数类型相同、使用非类型模板参数、更简洁地完美转发,还能结合 Concepts 进行约束。它让 lambda 具备了和普通函数模板同等的表达能力,在很多场景下可以替代单独定义的函数模板。