7、C++11 核心特性：Lambda表达式与std::function，函数式编程的敲门砖。

说实话，刚接触C++11那会儿，我对Lambda表达式是有点抵触的。心里想的是：“这玩意儿不就是个语法糖吗？我写个仿函数（Functor）不也一样？” 直到我在一个项目里，需要给一个复杂的排序算法传三个不同的比较逻辑，每个逻辑还都要捕获一些局部变量…… 写仿函数写到想吐。那一刻，我才真正体会到Lambda的好。

今天咱们就来聊聊这个“语法糖”，以及它的好搭档 std::function。它们俩，可以说是C++迈向函数式编程风格的敲门砖。

7.1 Lambda表达式：匿名函数的“速写本”

Lambda，说白了就是一个匿名的函数对象。你不需要专门去定义一个类或者结构体，直接在需要的地方“现写现用”。它的基本语法长这样：

[捕获列表] (参数列表) -> 返回类型 { 函数体 }

嗯，看着有点唬人。咱们拆开来看。

7.1.1 捕获列表：Lambda的灵魂

捕获列表决定了Lambda内部能访问外部作用域的哪些变量。这是Lambda和普通函数最大的区别。我见过不少新手在这里栽跟头。

• 值捕获 [=]：所有外部变量按值传入。Lambda内部拿到的是副本。注意，这个副本是只读的，除非你加上 mutable 关键字。
• 引用捕获 [&]：所有外部变量按引用传入。Lambda内部可以直接修改外部变量。但你要小心悬空引用的问题。
• 混合捕获 [=, &x]：除了x按引用捕获，其他都按值捕获。
• 特定捕获 [x, &y]：只捕获x（值）和y（引用）。

举个例子，你想想看：

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> data = {1, 2, 3, 4, 5, 6, 7, 8};
    int threshold = 5;
    int count = 0;

    // 值捕获 threshold，引用捕获 count
    std::for_each(data.begin(), data.end(), [threshold, &count](int x) {
        if (x > threshold) {
            ++count;
        }
    });

    std::cout << "大于 " << threshold << " 的元素个数: " << count << std::endl;
    return 0;
}

这段代码里，Lambda捕获了 threshold 的值和 count 的引用。为什么 count 要用引用？因为我们要在Lambda内部修改它。为什么 threshold 用值？因为我们只是读取它，而且不希望Lambda内部意外修改它。

7.1.2 参数列表与返回类型

参数列表和普通函数一样。返回类型可以省略，让编译器自动推导。但如果函数体里有多个返回语句，或者你想明确指定，就用 -> 返回类型。

// 自动推导返回类型
auto add = [](int a, int b) { return a + b; };

// 显式指定返回类型
auto divide = [](double a, double b) -> double {
    if (b == 0.0) {
        return 0.0; // 或者抛异常
    }
    return a / b;
};

嗯，这里要注意：如果Lambda体里只有一条 return 语句，编译器推导类型基本不会出错。但如果有多个 return 分支，最好显式声明返回类型，避免歧义。

7.2 std::function：函数的多态容器

Lambda好用，但它的类型是匿名的。你没法直接把它存到一个变量里，然后到处传递——除非你用 auto。但 auto 在函数参数、类成员变量等场景下就不好使了。

这时候 std::function 就登场了。它是一个通用的多态函数包装器。可以存储、复制、调用任何可调用对象：普通函数、Lambda、函数对象、成员函数指针……

它的声明在 <functional> 头文件里。基本用法：

#include <functional>
#include <iostream>

// 定义一个函数类型：接受两个int，返回int
std::function<int(int, int)> func;

// 赋值为一个普通函数
int add(int a, int b) { return a + b; }
func = add;
std::cout << func(3, 4) << std::endl; // 输出 7

// 赋值为一个Lambda
func = [](int a, int b) { return a * b; };
std::cout << func(3, 4) << std::endl; // 输出 12

// 赋值为一个函数对象
struct Multiply {
    int operator()(int a, int b) const { return a * b; }
};
func = Multiply();
std::cout << func(3, 4) << std::endl; // 输出 12

你看，同一个 std::function 对象，可以装下不同类型的可调用对象。这就是多态的魅力。

7.3 函数式编程的敲门砖

有了Lambda和 std::function，我们就可以在C++里玩一些函数式编程的花样了。比如高阶函数（接受函数作为参数，或者返回函数）。

举个例子，写一个通用的“重试”机制：

#include <functional>
#include <iostream>
#include <chrono>
#include <thread>

// 高阶函数：重试一个操作，最多 retryCount 次
template <typename Func>
auto retry(Func func, int retryCount, std::chrono::milliseconds delay) -> decltype(func()) {
    for (int i = 0; i < retryCount; ++i) {
        try {
            return func(); // 尝试执行
        } catch (const std::exception& e) {
            std::cerr << "尝试 " << (i+1) << " 失败: " << e.what() << std::endl;
            if (i == retryCount - 1) {
                throw; // 最后一次失败，重新抛出
            }
            std::this_thread::sleep_for(delay);
        }
    }
    // 不会执行到这里
    throw std::runtime_error("重试失败");
}

int main() {
    int attempt = 0;
    auto riskyOperation = [&attempt]() -> int {
        ++attempt;
        if (attempt < 3) {
            throw std::runtime_error("临时错误");
        }
        return 42;
    };

    try {
        int result = retry(riskyOperation, 5, std::chrono::milliseconds(100));
        std::cout << "最终结果: " << result << std::endl;
    } catch (const std::exception& e) {
        std::cerr << "操作最终失败: " << e.what() << std::endl;
    }
    return 0;
}

这个 retry 函数就是一个高阶函数。它接受一个可调用对象 func，然后帮你自动重试。你只需要把核心业务逻辑写成一个Lambda传进去就行。是不是很清爽？

7.4 知识体系图

为了让你更直观地理解Lambda和 std::function 在整个C++可调用对象体系中的位置，我画了张图：

从这张图可以看出来，Lambda、函数对象、普通函数是三种不同的“可调用对象”。而 std::function 就像一个万能插座，能把它们都装进去，统一调用。这就是函数式编程里“函数是一等公民”的思想在C++中的体现。

7.5 避坑指南与最佳实践

聊了这么多，最后分享几个我实际工作中总结的经验：

1. Lambda 尽量短小：如果一个Lambda超过10行，我建议你把它提取成一个具名函数或函数对象。可读性会好很多。
2. 小心引用捕获的生命周期：如果Lambda要存储起来（比如放到一个容器里），或者异步执行，引用捕获的变量可能已经销毁了。这时候用值捕获，或者用 std::shared_ptr 来管理生命周期。
3. 避免在性能热点使用 std::function：如前面所说，它有类型擦除的开销。在模板或 auto 能解决问题的地方，优先用模板。
4. 善用 mutable 但别滥用：值捕获的Lambda默认是 const 的。如果你确实需要修改捕获的值副本，加上 mutable。但这种情况通常意味着你的设计可能需要重新考虑。

好了，关于Lambda和 std::function 就聊到这儿。它们俩是C++11里最实用的特性之一，也是你迈向更高级编程范式的第一步。多用，多练，慢慢你就会发现，代码可以写得既简洁又强大。