Lambda 表达式是 C++11 引入的重要特性，它允许我们在代码中定义匿名函数，极大地简化了代码编写，尤其是在使用 STL 算法和多线程编程时。本文将详细介绍 Lambda 表达式的语法、特性及实际应用场景。

什么是 Lambda 表达式？

Lambda 表达式（也称为 lambda 函数）是一种匿名函数，即没有函数名的函数。它可以捕获周围作用域中的变量，并且可以像对象一样被传递和使用。Lambda 表达式的引入主要是为了简化函数对象的使用，特别是在需要短小函数作为参数的场景。

Lambda 表达式的基本结构如下：

[capture-list](parameter-list) mutable(optional) exception-specification(optional) -> return-type(optional) {// 函数体
}

各部分含义：

capture-list：捕获列表，指定从周围作用域捕获哪些变量及其捕获方式
parameter-list：参数列表，与普通函数的参数列表类似
mutable：可选关键字，允许在 lambda 体内修改按值捕获的变量
exception-specification：可选，指定 lambda 可能抛出的异常
return-type：可选，指定返回类型，若省略，编译器会自动推导
函数体：lambda 的执行代码

捕获列表详解

捕获列表决定了 lambda 表达式可以访问外部作用域中的哪些变量，以及如何访问（按值或按引用）。

捕获方式

按值捕获：[var] 或 [=]
- [var]：仅按值捕获变量 var
- [=]：按值捕获所有使用到的外部变量
按引用捕获：[&var] 或 [&]
- [&var]：仅按引用捕获变量 var
- [&]：按引用捕获所有使用到的外部变量
混合捕获：
- [=, &var]：除 var 按引用捕获外，其余按值捕获
- [&, var]：除 var 按值捕获外，其余按引用捕获
空捕获列表：[]
- 不捕获任何外部变量

捕获示例：

#include <iostream>int main() {int a = 10, b = 20;// 空捕获列表，不能访问a和bauto lambda1 = []() {std::cout << "Lambda1: 不捕获任何变量" << std::endl;};// 按值捕获a，按引用捕获bauto lambda2 = [a, &b]() {// a = 100; 错误：按值捕获的变量默认是const，不能修改b = 200;   // 正确：可以修改按引用捕获的变量std::cout << "Lambda2: a=" << a << ", b=" << b << std::endl;};// 按值捕获所有外部变量auto lambda3 = [=]() {std::cout << "Lambda3: a=" << a << ", b=" << b << std::endl;};// 按引用捕获所有外部变量auto lambda4 = [&]() {a = 100;b = 300;std::cout << "Lambda4: a=" << a << ", b=" << b << std::endl;};// 混合捕获：除b按值外，其余按引用auto lambda5 = [&, b]() {a = 200;// b = 400; 错误：b是按值捕获的std::cout << "Lambda5: a=" << a << ", b=" << b << std::endl;};lambda1();lambda2();lambda3();lambda4();lambda5();return 0;
}

mutable 关键字

默认情况下，按值捕获的变量在 lambda 体内是只读的。使用mutable关键字可以允许修改按值捕获的变量：

#include <iostream>int main() {int x = 10;// 不使用mutable，不能修改按值捕获的xauto lambda1 = [x]() {// x = 20; 错误std::cout << "lambda1: x=" << x << std::endl;};// 使用mutable，可以修改按值捕获的x（但不会影响外部的x）auto lambda2 = [x]() mutable {x = 20;std::cout << "lambda2内部: x=" << x << std::endl;};lambda1();lambda2();std::cout << "外部: x=" << x << std::endl;  // 仍然是10return 0;
}

返回类型

Lambda 表达式的返回类型通常可以由编译器自动推导，但在某些情况下（如有多条 return 语句且类型可能不同），需要显式指定返回类型：

#include <iostream>int main() {// 自动推导返回类型为intauto add = [](int a, int b) {return a + b;};// 显式指定返回类型auto divide = [](double a, double b) -> double {if (b == 0) return 0;return a / b;};std::cout << "3 + 5 = " << add(3, 5) << std::endl;std::cout << "10 / 3 = " << divide(10, 3) << std::endl;return 0;
}

Lambda 表达式的实际应用场景：

1. 作为 STL 算法的参数

这是 Lambda 表达式最常见的用途，尤其适合简短的谓词函数：

#include <iostream>
#include <vector>
#include <algorithm>int main() {std::vector<int> numbers = {3, 1, 4, 1, 5, 9, 2, 6};// 使用lambda排序（降序）std::sort(numbers.begin(), numbers.end(), [](int a, int b) {return a > b;});// 使用lambda过滤并打印std::cout << "大于3的元素: ";std::for_each(numbers.begin(), numbers.end(), [](int n) {if (n > 3) {std::cout << n << " ";}});std::cout << std::endl;return 0;
}

2. 在多线程中使用

Lambda 表达式非常适合作为线程函数：

#include <iostream>
#include <thread>
#include <vector>int main() {std::vector<std::thread> threads;int shared_data = 0;// 创建5个线程for (int i = 0; i < 5; ++i) {// 捕获i（按值）和shared_data（按引用）threads.emplace_back([i, &shared_data]() {std::cout << "线程 " << i << " 启动" << std::endl;// 模拟工作for (int j = 0; j < 1000000; ++j) {shared_data++;}std::cout << "线程 " << i << " 结束" << std::endl;});}// 等待所有线程完成for (auto& t : threads) {t.join();}std::cout << "最终shared_data值: " << shared_data << std::endl;return 0;
}

3. 作为函数返回值

Lambda 表达式可以被包装在std::function中作为函数返回值：

#include <iostream>
#include <functional>// 返回一个lambda表达式
std::function<int(int)> make_multiplier(int factor) {return [factor](int x) {return x * factor;};
}int main() {auto double_it = make_multiplier(2);auto triple_it = make_multiplier(3);std::cout << "5的两倍: " << double_it(5) << std::endl;   // 10std::cout << "5的三倍: " << triple_it(5) << std::endl;   // 15return 0;
}

4. 在条件判断中使用

可以在需要临时函数的地方直接定义 lambda：

#include <iostream>
#include <vector>
#include <string>int main() {std::vector<std::string> words = {"apple", "banana", "cherry", "date", "elderberry"};int min_length = 5;// 查找第一个长度小于min_length的单词auto it = std::find_if(words.begin(), words.end(), [min_length](const std::string& word) {return word.length() < min_length;});if (it != words.end()) {std::cout << "第一个短单词: " << *it << std::endl;  // 输出 "date"}return 0;
}

C++14 及以后版本的增强

C++14 对 lambda 表达式进行了一些有用的增强：

泛型 lambda：允许使用auto作为参数类型，使 lambda 更加灵活

// 泛型lambda，可以接受任何类型的参数
auto sum = [](auto a, auto b) {return a + b;
};int main() {std::cout << sum(3, 5) << std::endl;       // 8std::cout << sum(3.5, 2.5) << std::endl;   // 6.0std::cout << sum(std::string("Hello "), std::string("World")) << std::endl;  // Hello Worldreturn 0;
}

初始化捕获：可以在捕获列表中创建和初始化新变量

#include <iostream>
#include <memory>int main() {// 初始化捕获：创建一个unique_ptr并捕获它auto lambda = [ptr = std::make_unique<int>(42)]() {std::cout << "值: " << *ptr << std::endl;};lambda();  // 输出：值: 42return 0;
}

注意事项