18、C++14 新特性：泛型Lambda与Lambda捕获表达式，更灵活的匿名函数

聊到C++14，我脑子里第一个蹦出来的就是泛型Lambda。说实话，C++11刚引入Lambda时，大家都很兴奋——终于可以在函数体内写匿名函数了。但用着用着就发现一个问题：你没法写一个通用的Lambda，让它同时接受int、double、甚至自定义类型。每次都得用auto推导参数类型？嗯，C++11里还真不行。

C++14把这个短板补上了。它让Lambda的参数类型可以用auto，说白了就是模板化了。再加上捕获表达式的改进，匿名函数这块算是真正成熟了。

泛型Lambda：让匿名函数也能模板化

先看个最简单的例子。C++11里，你要写一个接受两个参数的Lambda，必须显式指定类型：

// C++11 写法
auto add = [](int a, int b) { return a + b; };
// 想支持double？再写一个
auto add_double = [](double a, double b) { return a + b; };

这多麻烦。你想想看，如果代码里到处都是这种重复的Lambda，维护起来简直要命。C++14直接让参数变成auto：

// C++14 泛型Lambda
auto add = [](auto a, auto b) { return a + b; };

std::cout << add(3, 4) << std::endl;       // int
std::cout << add(3.14, 2.71) << std::endl; // double
std::cout << add(std::string("Hello "), 
                   std::string("World")) << std::endl; // string

这里auto不是运行时推导，而是编译期生成一个模板。每次调用时，编译器会根据实际参数类型实例化一个对应的Lambda。我在项目中遇到过类似场景——需要写一个通用的排序比较器，用泛型Lambda一行搞定，不用再写一堆重载函数。

泛型Lambda的底层原理

为什么说它是模板？我们来看编译器实际生成的东西。你写的：

auto lambda = [](auto x, auto y) { return x + y; };

编译器会把它展开成类似这样的结构：

class __lambda_xxx {
public:
    template<typename T1, typename T2>
    auto operator()(T1 x, T2 y) const {
        return x + y;
    }
};

所以泛型Lambda的每个auto参数，都对应一个独立的模板参数。这意味着你可以写出非常灵活的代码。比如：

auto print = [](const auto& container) {
    for (const auto& elem : container) {
        std::cout << elem << " ";
    }
    std::cout << std::endl;
};

std::vector<int> vec = {1, 2, 3};
std::list<std::string> lst = {"a", "b", "c"};
print(vec); // 打印vector
print(lst); // 打印list

我个人习惯把这种泛型Lambda用在算法参数里，比如std::sort、std::transform，配合auto参数，代码简洁又通用。

Lambda捕获表达式：初始化捕获

C++14另一个让我拍大腿的特性是捕获表达式的改进。C++11只支持按值捕获和按引用捕获，而且捕获的变量必须是外部作用域已经存在的。如果你想捕获一个移动语义的对象，或者捕获一个临时计算的结果，C++11就无能为力了。

举个例子。你想在Lambda里持有一个std::unique_ptr，C++11里你没法直接捕获它，因为unique_ptr不能拷贝。C++14的初始化捕获解决了这个问题：

auto p = std::make_unique<int>(42);

// C++14 初始化捕获
auto lambda = [ptr = std::move(p)]() {
    std::cout << *ptr << std::endl;
};

lambda(); // 输出42
// 此时p已经为空

这里ptr = std::move(p)就是在捕获时初始化了一个新变量ptr，它拥有p的所有权。这种写法在C++11里根本做不到。

我曾经在写异步任务队列时遇到过这个问题。需要把一些资源移动到Lambda里，然后在另一个线程中执行。没有初始化捕获，就得用shared_ptr绕一圈，既麻烦又影响性能。

初始化捕获的更多用法

初始化捕获不只是用来移动对象，它还可以捕获表达式的结果。比如：

// 捕获一个计算后的值
auto lambda = [result = 1 + 2 + 3]() {
    std::cout << result << std::endl;
};

或者捕获一个临时对象：

auto lambda = [vec = std::vector<int>{1, 2, 3, 4, 5}]() {
    for (int x : vec) {
        std::cout << x << " ";
    }
};

你想想看，这相当于在Lambda内部定义了一个局部变量，而且这个变量的生命周期和Lambda绑定在一起。对于需要携带状态但又不想定义函数对象的场景，非常实用。

泛型Lambda + 初始化捕获的组合威力

把这两个特性结合起来，能写出非常灵活的代码。比如实现一个通用的延迟计算器：

template<typename F>
auto make_lazy(F f) {
    return [f = std::move(f)]() {
        return f();
    };
}

auto lazy_add = make_lazy([](int a, int b) { 
    return a + b; 
});

// 注意：这里返回的是Lambda，不是计算结果
// 调用时才真正计算
auto result = lazy_add(); // 编译错误！因为lazy_add不接受参数

嗯，上面的例子有点小问题。我们改进一下，让泛型Lambda和初始化捕获一起工作：

auto make_lazy = [](auto func, auto... args) {
    return [func = std::move(func), 
            args = std::make_tuple(std::move(args)...)]() {
        return std::apply(func, args);
    };
};

auto lazy_add = make_lazy([](int a, int b) { return a + b; }, 3, 4);
std::cout << lazy_add() << std::endl; // 输出7

这里用到了C++17的std::apply，但核心思想是C++14的。泛型Lambda处理参数类型，初始化捕获保存参数和函数对象。这种组合在函数式编程风格中特别有用。

知识体系总览

下面这张图帮你理清C++14 Lambda新特性的核心脉络：

避坑指南：我踩过的几个坑

讲几个实际开发中容易出问题的地方。

坑一：泛型Lambda的返回类型推导

我曾经写过一个泛型Lambda，用来比较两个值的大小：

auto cmp = [](auto a, auto b) { return a < b; };

看起来没问题对吧？但如果a和b类型不同，比如一个是int一个是double，编译器会推导出不同的模板参数。这时候如果Lambda体里做了类型相关的操作，可能会出问题。我的建议是：如果类型可能不同，显式用decltype处理一下。

坑二：初始化捕获中的引用问题

初始化捕获默认是按值捕获的。如果你想捕获引用，得用std::ref：

int x = 10;
auto lambda = [&ref = std::ref(x)]() {
    ref.get() = 20;
};
lambda();
std::cout << x << std::endl; // 输出20

直接写[&ref = x]是不行的，那会把x拷贝一份。嗯，这里要特别注意。

坑三：泛型Lambda的递归调用

泛型Lambda不能直接递归调用自己，因为Lambda本身没有名字。如果你需要递归，可以用std::function包装，或者用Y组合子。我个人建议用std::function，简单直接：

std::function<int(int)> factorial = [&](int n) {
    return n <= 1 ? 1 : n * factorial(n - 1);
};

实际项目中的应用场景

我在做配置解析器时用过泛型Lambda。需要把不同类型的配置项（int、double、string）统一处理，但又不想写模板函数。用泛型Lambda配合std::variant，代码非常简洁：

std::variant<int, double, std::string> value = 42;

auto visitor = [](auto&& arg) {
    using T = std::decay_t<decltype(arg)>;
    if constexpr (std::is_same_v<T, int>) {
        std::cout << "int: " << arg << std::endl;
    } else if constexpr (std::is_same_v<T, double>) {
        std::cout << "double: " << arg << std::endl;
    } else if constexpr (std::is_same_v<T, std::string>) {
        std::cout << "string: " << arg << std::endl;
    }
};

std::visit(visitor, value);

这里auto&&是泛型Lambda的参数，配合if constexpr（C++17），实现了编译期的类型分发。虽然用到了C++17的特性，但泛型Lambda的功劳不可忽视。

最后说一句，这些特性虽然看起来简单，但用好了能大幅提升代码质量。我建议你在日常开发中多尝试，尤其是那些需要临时函数对象的场景——用Lambda比写一个完整的函数对象类要省事得多。

---