C++11 新特性系列（六）：Lambda 表达式与函数式编程

本系列的第六篇，我们将探索 C++11 中最受欢迎的特性之一——Lambda 表达式。它让 C++ 拥有了在函数内部定义匿名函数的能力，配合标准库算法，使代码更加简洁、优雅。Lambda 表达式的引入，标志着 C++ 在函数式编程道路上迈出了坚实的一步。

---

一、从函数指针到 Lambda：为什么需要 Lambda？

在 C++98 中，我们通常用三种方式向算法传递自定义操作：

1. 函数指针
2. 函数对象（Functor）
3. 绑定器（std::bind 等）

每种方式都有其局限性：

函数指针：

bool compare(int a, int b) {
    return a > b;
}
std::sort(vec.begin(), vec.end(), compare);

缺点：函数必须定义在全局或静态作用域，代码分散，难以捕获上下文信息。

函数对象：

struct Compare {
    bool operator()(int a, int b) const {
        return a > b;
    }
};
std::sort(vec.begin(), vec.end(), Compare());

缺点：需要定义额外的类/结构体，代码冗长，尤其是只需要使用一次的场景。

绑定器（C++98 的 std::bind1st/std::bind2nd）：

std::transform(vec.begin(), vec.end(), result, 
               std::bind2nd(std::multiplies<int>(), 2));

缺点：语法晦涩，功能有限，难以组合。

C++11 的 Lambda 表达式完美解决了这些问题——它允许在使用的地方直接定义匿名函数，能够捕获局部变量，语法简洁且表达力强。

---

二、Lambda 表达式的基础语法

2.1 完整语法形式

Lambda 表达式的完整语法如下：

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

各个部分说明：

• 捕获列表 []：指定哪些外部变量可以被 lambda 访问，以及如何访问（值或引用）。
• 参数列表 ()：与普通函数的参数列表相同，C++14 起支持 auto 参数（泛型 lambda）。
• mutable：如果捕获列表按值捕获，默认 lambda 不能修改这些拷贝；加上 mutable 可以修改（但不会影响原始变量）。
• 异常说明：noexcept 等，与普通函数相同。
• 返回类型 -> type：可以显式指定返回类型，也可以省略（编译器自动推导）。
• 函数体 {}：执行的代码。

2.2 最简单的 Lambda

auto lambda = [] { std::cout << "Hello Lambda!" << std::endl; };
lambda();  // 输出：Hello Lambda!

• 捕获列表为空 []：不捕获任何外部变量。
• 参数列表为空 ()：可以省略（没有参数时可省略括号）。
• 返回类型省略：函数体只有 std::cout，返回 void。

2.3 带参数的 Lambda

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

返回类型可以省略，编译器自动推导为 int：

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

2.4 带返回类型的 Lambda

当 lambda 的函数体包含多个 return 语句时，或者返回类型不是 void 但函数体没有 return 语句时，需要显式指定返回类型：

auto conditional = [](int x) -> double {
    if (x > 0) return x * 1.5;
    return 0.0;
};

如果省略返回类型，编译器会尝试推导，但推导规则与 auto 相同（不保留引用等）。

---

三、捕获列表：Lambda 的核心能力

捕获列表是 lambda 最强大的特性，它决定了外部变量如何进入 lambda 的作用域。

3.1 捕获方式总览

捕获方式	语法	说明
空捕获	[]	不捕获任何外部变量
值捕获	[x]	捕获变量 x 的副本（按值）
引用捕获	[&x]	捕获变量 x 的引用
隐式值捕获	[=]	按值捕获所有使用到的外部变量
隐式引用捕获	[&]	按引用捕获所有使用到的外部变量
混合捕获	[=, &x]	默认值捕获，但 x 用引用捕获
混合捕获	[&, x]	默认引用捕获，但 x 用值捕获
初始化捕获	[x = 0]	C++14 特性，捕获时初始化

3.2 各种捕获方式的示例

值捕获：

int x = 10;
auto lambda = [x]() { 
    // x 是只读的拷贝
    std::cout << x << std::endl; 
};
x = 20;
lambda();  // 输出 10（捕获的是创建时的值）

值捕获在 lambda 创建时复制变量的值，之后原始变量的改变不会影响 lambda 内部的副本。

引用捕获：

int x = 10;
auto lambda = [&x]() { 
    x += 5;  // 修改的是原始变量
    std::cout << x << std::endl; 
};
lambda();  // 输出 15
std::cout << x << std::endl;  // 输出 15

引用捕获捕获的是变量的引用，可以修改原始变量，并且能感知原始变量的变化。

隐式值捕获 [=]：

int a = 1, b = 2;
auto lambda = [=]() { 
    std::cout << a + b << std::endl;  // 自动按值捕获 a 和 b
};

隐式引用捕获 [&]：

int a = 1, b = 2;
auto lambda = [&]() { 
    a += b;  // 自动按引用捕获 a 和 b
};

混合捕获：

int a = 1, b = 2, c = 3;
auto lambda = [=, &b]() { 
    // b 是引用，a 和 c 是值拷贝
    b += a + c;
};

3.3 捕获的注意事项与陷阱

陷阱1：引用捕获的悬垂引用

auto createLambda() {
    int local = 42;
    return [&local]() { return local; };  // 危险！local 被销毁后，引用悬垂
}
auto lambda = createLambda();
// lambda()  // 未定义行为！local 已不存在

解决方案：按值捕获 [local]，或确保引用的对象生命周期长于 lambda。

陷阱2：值捕获的只读性

默认情况下，按值捕获的变量在 lambda 内部是只读的（类似于 const 变量）：

int x = 10;
auto lambda = [x]() { 
    // x += 1;  // 错误！x 是只读的
};

如果需要修改副本，使用 mutable：

int x = 10;
auto lambda = [x]() mutable { 
    x += 1;   // OK，修改的是副本
    return x;
};
std::cout << lambda() << std::endl;  // 输出 11
std::cout << lambda() << std::endl;  // 输出 12（副本持续累积）
std::cout << x << std::endl;         // 输出 10（原始变量未变）

注意：mutable 不影响原始变量，只允许修改 lambda 内部维护的副本。

陷阱3：[=] 捕获的变量不是按引用

[=] 看起来像“按值捕获所有变量”，但它捕获的是在 lambda 体内使用到的变量，不是全部外部变量。而且这些变量是只读的。

陷阱4：成员变量的捕获

在类成员函数中定义 lambda 时，[this] 或 [=] 可以捕获 this 指针，从而访问成员变量：

class MyClass {
    int member = 10;
public:
    void test() {
        // 方式1：显式捕获 this
        auto lambda1 = [this]() { 
            return member;   // 通过 this->member 访问
        };
        
        // 方式2：使用 [=] 隐式捕获 this
        auto lambda2 = [=]() { 
            return member;   // 也捕获 this
        };
        
        // 如果不想捕获 this，用 [] 则不能访问成员
        auto lambda3 = []() { 
            // return member;  // 错误！无法访问
        };
    }
};

在 C++17 中，推荐使用 [*this] 按值捕获整个对象（C++11 不支持），或显式用 [this]。

---

四、Lambda 的类型与存储

4.1 Lambda 的类型

每个 lambda 表达式都有一个独一无二的、匿名的类类型，由编译器生成。这称为闭包类型（closure type）。

auto lambda1 = [] { return 1; };
auto lambda2 = [] { return 1; };
// lambda1 和 lambda2 的类型不同（即使代码完全相同）！

lambda 类型是特殊的类类型，具有：

• 重载的 operator()（函数调用运算符）。
• 捕获的变量作为成员变量（按值捕获）或引用成员（按引用捕获）。
• 默认的拷贝构造函数和赋值运算符（除非捕获了不可拷贝的对象）。

4.2 存储 Lambda

由于 lambda 类型是匿名的，我们通常用 auto 来声明 lambda 变量。但如果需要存储或传递 lambda（比如作为类成员），可以用：

（1）std::function

#include <functional>
std::function<int(int)> func = [](int x) { return x * 2; };
func(10);  // 输出 20

std::function 可以存储任意可调用对象（lambda、函数指针、函数对象），但会带来一些运行时开销。

（2）模板参数

在泛型代码中，可以直接将 lambda 作为模板参数（如传递给 std::sort），编译器会内联优化。

template<typename Callable>
void execute(Callable&& f) {
    f();
}
execute([] { std::cout << "Hello\n"; });

---

五、Lambda 与标准库算法的结合

Lambda 最大的价值在于配合标准库算法，让代码变得极其简洁。

5.1 排序

#include <vector>
#include <algorithm>
#include <string>

std::vector<std::string> names = {"Alice", "Bob", "Charlie", "David"};

// 按长度降序排序
std::sort(names.begin(), names.end(), 
          [](const std::string& a, const std::string& b) {
              return a.size() > b.size();
          });

5.2 查找

std::vector<int> numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

// 查找第一个大于 5 的元素
auto it = std::find_if(numbers.begin(), numbers.end(),
                       [](int x) { return x > 5; });
if (it != numbers.end()) {
    std::cout << "Found: " << *it << std::endl;
}

5.3 变换

std::vector<int> src = {1, 2, 3, 4, 5};
std::vector<int> dst(src.size());

// 每个元素乘以 2
std::transform(src.begin(), src.end(), dst.begin(),
               [](int x) { return x * 2; });

5.4 累积/归约

#include <numeric>
std::vector<int> nums = {1, 2, 3, 4, 5};

// 计算所有偶数的平方和
int sum = std::accumulate(nums.begin(), nums.end(), 0,
                          [](int acc, int x) {
                              if (x % 2 == 0) {
                                  return acc + x * x;
                              }
                              return acc;
                          });

5.5 删除元素（配合 erase-remove）

std::vector<int> nums = {1, 2, 3, 4, 5, 6, 7, 8};

// 删除所有偶数
nums.erase(std::remove_if(nums.begin(), nums.end(),
                          [](int x) { return x % 2 == 0; }),
           nums.end());

5.6 捕获局部变量进行复杂操作

int threshold = 5;
int sum = 0;
std::for_each(nums.begin(), nums.end(),
              [&, threshold](int x) {
                  if (x > threshold) {
                      sum += x;
                  }
              });

---

六、Lambda 的深度剖析：闭包与函数对象

6.1 闭包（Closure）

Lambda 表达式生成的匿名类对象被称为闭包。它包含了：

• 捕获的变量（值捕获的副本，或引用捕获的引用）。
• 重载的 operator()。

编译器生成的闭包类型大致如下（对于 lambda [x](int y) { return x + y; }）：

class __lambda_unique_name {
private:
    int x;  // 按值捕获的变量
public:
    __lambda_unique_name(int _x) : x(_x) {}
    
    auto operator()(int y) const -> int {
        return x + y;
    }
};

对于 [&x] 捕获：

class __lambda_unique_name {
private:
    int& x;  // 引用捕获
public:
    __lambda_unique_name(int& _x) : x(_x) {}
    
    auto operator()(int y) const -> int {
        return x + y;
    }
};

6.2 为什么不使用函数对象替代 Lambda？

虽然 Lambda 底层就是函数对象，但：

• Lambda 的语法更简洁、本地化。
• Lambda 自动推导参数和返回类型（在某些场景）。
• Lambda 支持捕获列表，语义更清晰。
• 代码可读性更高，减少样板代码。

---

七、常见陷阱与最佳实践

陷阱1：在循环中捕获引用导致悬垂

std::vector<std::function<int()>> funcs;
for (int i = 0; i < 10; ++i) {
    funcs.push_back([&i]() { return i; });  // 所有 lambda 捕获同一个 i 的引用
}
for (auto& f : funcs) {
    std::cout << f() << " ";  // 输出 10 10 10 ...（循环结束后 i = 10）
}

解决：按值捕获 [i]，每个 lambda 拥有独立的副本。

陷阱2：按值捕获大对象时的性能问题

std::vector<int> hugeVec(1000000);
auto lambda = [hugeVec]() { /* ... */ };  // 拷贝整个向量！

解决：按引用捕获 [&hugeVec]，或使用移动捕获（C++14 的初始化捕获）。

陷阱3：过长的 lambda 体

如果 lambda 体超过几行，会影响代码可读性。应考虑提取为具名函数或函数对象。

陷阱4：忘记指定返回类型导致推导错误

auto lambda = [](int x) {
    if (x > 0) return x;
    return 0.0;   // 错误！推导为 int，但第二个返回 double，类型冲突
};

解决：显式指定返回类型 -> double。

陷阱5：在 lambda 中使用 auto 参数（C++11 不支持）

C++14 才支持泛型 lambda，C++11 中参数类型必须显式指定。

// C++14
auto generic = [](auto x) { return x; };

// C++11 必须显式类型
auto explicit = [](int x) { return x; };

最佳实践总结

1. 尽量使用值捕获 [=]，除非需要修改外部变量或担心性能。
2. 避免在返回的 lambda 中捕获局部变量的引用。
3. 保持 lambda 简短，过长时考虑提取为命名函数。
4. 显式指定返回类型，当函数体中有多个 return 或需要特定类型转换时。
5. 使用 const 引用捕获（[&] 默认是引用，可直接修改；若需只读，可考虑值捕获或额外加 const）。
6. 优先使用 lambda 代替 std::bind，更易读且更高效。

---

八、std::bind 的退化：为什么 Lambda 优于 bind

在 C++98 中，std::bind（以及 std::bind1st/std::bind2nd）用于绑定参数，但存在许多问题：

（1）语法晦涩

using namespace std::placeholders;
auto plus10 = std::bind(std::plus<int>(), _1, 10);

（2）调试困难

std::bind 的错误信息极其复杂，难以阅读。

（3）性能问题

std::bind 往往无法内联，而 lambda 可以轻松内联。

（4）类型安全不足

std::bind 对类型擦除较多，与模板配合时易出错。

Lambda 替代方案：

auto plus10 = [](int x) { return x + 10; };  // 简洁明了

在 C++11 中，std::bind 仅在少数场景（如需要绑定成员函数并保留占位符顺序）可能仍有使用价值，但大多数场景完全可用 lambda 替换。

---

九、综合示例：一个完整的 Lambda 应用

#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <functional>

struct Employee {
    std::string name;
    int age;
    double salary;
};

int main() {
    std::vector<Employee> employees = {
        {"Alice", 28, 50000.0},
        {"Bob", 35, 75000.0},
        {"Charlie", 22, 40000.0},
        {"David", 40, 90000.0},
        {"Eve", 30, 60000.0}
    };
    
    // 1. 按年龄排序
    std::sort(employees.begin(), employees.end(),
              [](const Employee& a, const Employee& b) {
                  return a.age < b.age;
              });
    
    // 2. 筛选薪水高于 50000 的员工
    double threshold = 50000.0;
    std::vector<Employee> highSalary;
    std::copy_if(employees.begin(), employees.end(),
                 std::back_inserter(highSalary),
                 [&](const Employee& e) {
                     return e.salary > threshold;
                 });
    
    // 3. 计算平均年龄
    int totalAge = 0;
    std::for_each(highSalary.begin(), highSalary.end(),
                  [&](const Employee& e) {
                      totalAge += e.age;
                  });
    double avgAge = highSalary.empty() ? 0.0 : 
                    static_cast<double>(totalAge) / highSalary.size();
    
    // 4. 输出结果
    std::cout << "High-salary employees ( > " << threshold << " ):\n";
    std::for_each(highSalary.begin(), highSalary.end(),
                  [](const Employee& e) {
                      std::cout << "  " << e.name 
                                << ", age " << e.age 
                                << ", salary $" << e.salary << "\n";
                  });
    std::cout << "Average age: " << avgAge << std::endl;
    
    // 5. 使用 std::function 存储 lambda
    std::function<double(const Employee&)> getBonus = 
        [](const Employee& e) {
            return e.salary * 0.1;  // 10% 奖金
        };
    std::cout << "Bonus for " << employees[0].name 
              << ": $" << getBonus(employees[0]) << std::endl;
    
    // 6. 使用 mutable 的 lambda 统计调用次数
    int counter = 0;
    auto countingPrint = [&, name = std::string("Counter")]() mutable {
        // C++14 的初始化捕获示例，这里为了演示 C++11，改为：
        // std::cout << "Called " << ++counter << " times\n";
        // 实际上 C++11 不支持初始化捕获，我们用普通的捕获：
        std::cout << "Called " << ++counter << " times\n";
    };
    countingPrint();  // Called 1 times
    countingPrint();  // Called 2 times
    
    return 0;
}

---

十、C++11 Lambda 的限制与前瞻

虽然 C++11 的 lambda 已经很强大，但仍有以下限制（后续标准中已改进）：

1. 不支持泛型 lambda（C++14 支持 auto 参数）。
2. 不支持捕获表达式（C++14 的初始化捕获）。
3. 不支持 constexpr lambda（C++17 支持）。
4. 不支持模板参数（C++20 支持）。
5. 无法捕获仅可移动对象（C++14 的初始化捕获可解决）。

不过，对于 C++11 来说，以上特性已经足够日常使用。

---

总结

主题	核心内容
Lambda 语法	[捕获](参数)->返回类型{函数体}
捕获列表	[]、[x]、[&x]、[=]、[&]、混合捕获
mutable 修饰	允许修改按值捕获的副本
闭包类型	编译器生成的匿名类，重载 operator()
与算法结合	极大简化 sort、find_if、transform 等
替代 std::bind	lambda 更清晰、更高效
常见陷阱	引用捕获悬垂、按值捕获大对象、返回类型推导

Lambda 表达式是 C++11 中极具革命性的特性之一。它让 C++ 的代码更加简洁、优雅，并极大提升了标准库算法的可用性。掌握了 lambda，你将能够编写出更具表达力的现代 C++ 代码。

---

下一篇预告：我们将进入 智能指针 的世界。std::unique_ptr、std::shared_ptr 和 std::weak_ptr 将彻底改变你的内存管理方式，告别裸指针带来的内存泄漏和悬垂问题。敬请期待！