C++11标准引入的lambda表达式是一种定义匿名函数的语法特性，它允许开发者在代码执行位置直接定义函数逻辑，无需提前声明独立的函数或函数对象，在简化函数操作、减少代码冗余方面有显著作用。
lambda表达式的基础语法
lambda表达式的基本结构由捕获列表、参数列表、返回类型说明和函数体组成，最简形式可以省略部分可选部分。基础语法格式如下：
[捕获列表](参数列表) -> 返回类型 {
函数体
}
其中捕获列表和函数体是必须的部分，参数列表、返回类型可以根据实际情况省略。当函数体只有一条return语句时，编译器可以自动推导返回类型，无需显式声明。
下面是一个最简单的lambda表达式示例，实现两个数相加的功能：
#include <iostream>
int main() {
// 定义lambda表达式并赋值给变量add
auto add = [](int a, int b) {
return a + b;
};
// 调用lambda表达式
std::cout << add(3, 5) << std::endl; // 输出8
return 0;
}
lambda的变量捕获规则
lambda表达式的核心优势之一是可以通过捕获列表获取上下文中的变量，无需将变量作为参数传递。常见的捕获方式有值捕获、引用捕获和隐式捕获。
值捕获
值捕获会将上下文变量的值拷贝到lambda表达式内部，拷贝发生在lambda表达式定义时，后续外部变量修改不会影响lambda内部的拷贝值。
#include <iostream>
int main() {
int x = 10;
// 值捕获x
auto func = [x]() {
std::cout << "捕获的x值：" << x << std::endl;
};
x = 20; // 修改外部x的值
func(); // 输出 捕获的x值：10，不受外部修改影响
return 0;
}
引用捕获
引用捕获会捕获外部变量的引用，lambda内部操作的是外部变量的本身，外部变量的修改会影响lambda内部的值，反之亦然。
#include <iostream>
int main() {
int x = 10;
// 引用捕获x
auto func = [&x]() {
x += 5; // 修改捕获的引用，会影响外部x
std::cout << "lambda内部x值：" << x << std::endl;
};
func();
std::cout << "外部x值：" << x << std::endl; // 输出15
return 0;
}
隐式捕获
如果不想逐个列出要捕获的变量，可以使用隐式捕获让编译器自动推导捕获的变量。<code>[=]</code>表示以值捕获的方式捕获所有用到的外部变量，<code>[&]</code>表示以引用捕获的方式捕获所有用到的外部变量。
#include <iostream>
int main() {
int a = 1, b = 2, c = 3;
// 隐式值捕获，自动捕获用到的a和b
auto sum1 = [=]() {
return a + b;
};
// 隐式引用捕获，自动捕获用到的c
auto modifyC = [&]() {
c = 10;
};
std::cout << sum1() << std::endl; // 输出3
modifyC();
std::cout << c << std::endl; // 输出10
return 0;
}
用lambda简化STL算法操作
在没有lambda表达式之前，使用STL算法（如<code>std::sort</code>、<code>std::for_each</code>、<code>std::count_if</code>等）往往需要定义独立的比较函数或函数对象，代码分散且可读性差。使用lambda可以直接在算法调用处定义操作逻辑，大幅简化代码。
简化排序操作
比如对自定义结构体数组排序，传统方式需要定义独立的比较函数，使用lambda可以直接在<code>std::sort</code>调用处定义排序规则。
#include <iostream>
#include <vector>
#include <algorithm>
struct Student {
std::string name;
int score;
};
int main() {
std::vector<Student> students = {
{"张三", 85},
{"李四", 92},
{"王五", 78}
};
// 使用lambda定义排序规则：按分数降序排序
std::sort(students.begin(), students.end(), [](const Student& a, const Student& b) {
return a.score > b.score;
});
for (const auto& stu : students) {
std::cout << stu.name << " 分数：" << stu.score << std::endl;
}
return 0;
}
简化遍历和条件统计
使用<code>std::for_each</code>遍历元素、<code>std::count_if</code>统计符合条件的元素时，lambda可以让逻辑更集中。
#include <iostream>
#include <vector>
#include <algorithm>
int main() {
std::vector<int> nums = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
// 遍历输出所有元素
std::for_each(nums.begin(), nums.end(), [](int num) {
std::cout << num << " ";
});
std::cout << std::endl;
// 统计大于5的元素个数
int count = std::count_if(nums.begin(), nums.end(), [](int num) {
return num > 5;
});
std::cout << "大于5的元素个数：" << count << std::endl; // 输出5
return 0;
}
lambda替代函数对象的场景
传统的函数对象需要定义一个类并重载<code>operator()</code>，代码量较多。对于简单的、一次性使用的函数逻辑，用lambda替代函数对象可以减少代码量，提升可读性。
比如实现一个简单的累加器，传统函数对象实现如下：
#include <iostream>
// 传统函数对象
struct Accumulator {
int sum;
Accumulator(int init) : sum(init) {}
void operator()(int num) {
sum += num;
}
};
int main() {
int arr[] = {1, 2, 3, 4};
Accumulator acc(0);
for (int num : arr) {
acc(num);
}
std::cout << "累加结果：" << acc.sum << std::endl; // 输出10
return 0;
}
使用lambda实现的等效代码更简洁：
#include <iostream>
int main() {
int arr[] = {1, 2, 3, 4};
int sum = 0;
// 引用捕获sum，直接累加
auto accumulator = [&sum](int num) {
sum += num;
};
for (int num : arr) {
accumulator(num);
}
std::cout << "累加结果：" << sum << std::endl; // 输出10
return 0;
}
使用注意事项
- lambda表达式默认是const的，如果需要在值捕获的变量被修改，需要在参数列表后添加<code>mutable</code>关键字，不过这种情况一般建议优先使用引用捕获。
- 不要过度使用lambda，对于复杂、需要复用的函数逻辑，还是建议定义为独立的函数，提升代码的可维护性。
- 捕获引用时要注意变量的生命周期，避免lambda内部持有已经销毁的变量引用，导致悬空引用问题。
总的来说，lambda表达式是C++中简化函数操作的重要工具，合理使用可以减少冗余代码，让函数逻辑更集中，提升代码的可读性和可维护性，尤其适合搭配STL算法和一次性函数场景使用。