一、语法
1.基础语法
[capture](paramLists) mutable ->retunType{statement}- capture。捕获列表，用于捕获前文的变量供lambda函数中使用，可省略。
- (paramLists)。参数列表，可省略。
- mutable。lambda表达式默认具有常量性，可以通过mutable取消常量性，可省略。
- returnType。函数返回类型，可省略。
- statement。函数体，可省略。
结合上述可省略的内容，C++11中最简单的lambda表达式可以是（虽然没有实际意义）：
[]{}2.捕获列表
lambda函数的与普通函数最大的区别在于可以捕获前文的局部变量(仅仅对于局部而言，如果是全局lambda函数则不支持)。而捕获的方式有：
- [var]表示值传递方式捕获变量var
- [=]表示值传递方式捕获父作用域所有变量（包括this）
- [&var]表示引用传递方式捕获变量var
- [&]表示引用传递方式捕获父作用域所有变量（包括this）
- [this]表示值传递方式捕获变量this
而由于捕获列表支持多个值（用,分隔），因此可以进行组合：
- [=,&a,&b]表示引用传递捕获a，b，值传递捕获其他内容。
- [&,a,this]表示值传递捕获a，this，引用传递捕获其他内容。
需要注意的是，捕获列表不能重复，如
[=,a,b]或者[&,&a,&b]等都是重复捕获(以相同的传递方式捕获同一个变量)。
3.基础使用
lambda函数通常用于局部作用域作为局部[匿名]函数。
extern int z;
extern float c;
void Calc(int& , int, float &, float);
void TestCalc() {
int x, y = 3;
float a, b = 4.0;
int success = 0;
auto validate = [&]() -> bool
{
if ((x == y + z) && (a == b + c))
return 1;
else
return 0;
};
Calc(x, y, a, b);
success += validate();
y = 1024;
b = 1e13;
Calc(x, y, a, b);
success += validate();
}
// 编译选项:g++ -c -std=c++11 7-3-7.cpp
而在有时会通过auto为lambda函数命名，使其获得自说明性。
与普通函数相比lambda有如下优势：
- 支持直接在函数内创建，作用域外释放，而不用额外创建一个函数。
- 能够直接捕获所有局部变量，而普通函数则需要额外传递。
- lambda函数默认内联，在较多次调用时性能比普通函数好。
- lambda函数的设计更简单，不需要考虑参数传递等问题
二、关于lambda的一些实验与讨论
1.捕获参数的传递方式
lambda函数中不同的捕获传递方式会造成不同的结果，对于值传递，则在传递的值在编译期就确定了，无法被修改，而对于引用传递则可以同步lambda函数外的修改。
#include <iostream>
using namespace std;
int main() {
int j = 12;
auto by_val_lambda = [=] { return j + 1;};
auto by_ref_lambda = [&] { return j + 1;};
cout << "by_val_lambda: " << by_val_lambda() << endl;
cout << "by_ref_lambda: " << by_ref_lambda() << endl;
j++;
cout << "by_val_lambda: " << by_val_lambda() << endl;
cout << "by_ref_lambda: " << by_ref_lambda() << endl;
}运行结果：
by_val_lambda: 13
by_ref_lambda: 13
by_val_lambda: 13
by_ref_lambda: 142.与函数指针的关系
lambda函数与函数指针看起来很相似，但是实际上却不是函数指针，它是一种称为"闭包"(closure)的类。
这种类型支持向函数指针转换，前提是：
- lambda函数不捕获任何变量
- 函数指针的原型与lambda一致(参数，返回值都完全一致)
int main() {
int girls = 3, boys = 4;
auto totalChild = [](int x, int y)->int{ return x + y; };
typedef int (*allChild)(int x, int y);
typedef int (*oneChild)(int x);
allChild p;
p = totalChild;
oneChild q;
q = totalChild; // 编译失败，参数必须一致
decltype(totalChild) allPeople = totalChild; // 需通过decltype获得lambda的类型
decltype(totalChild) totalPeople = p; // 编译失败，指针无法转换为lambda
return 0;
}
// 编译选项:g++ -std=c++11 7-3-10.cpp
此外，不支持函数指针向lambda转换
3.常量性与mutable
前面提到对于值传递的捕获参数具有常量性无法被修改，而想要打破这一限制，可以加上mutable关键字。(注意虽然可以修改，但仍然不影响父作用域变量)
#include <iostream>
int main() {
int val=0;
// 编译失败, 在const的lambda中修改常量
//auto const_val_lambda = [=]() { val = 3; };
// 非const的lambda,可以修改常量数据
auto mutable_val_lambda = [=]() mutable { val = 3; };
mutable_val_lambda();
std::cout << val << std::endl;
// 依然是const的lambda，不过没有改动引用本身
auto const_ref_lambda = [&] { val = 4; };
const_ref_lambda();
std::cout << val << std::endl;
// 依然是const的lambda，通过参数传递val
auto const_param_lambda = [&](int v) { v = 5; };
const_param_lambda(val);
std::cout << val << std::endl;
return 0;
}而对于引用传递方式，则表示lambda捕获的参数引用了父作用域的变量，一边修改都会同步到另一边。
三、lambda与STL
前面说到，lambda对C++11最大的贡献，或者说是改变，应该在STL库中。这主要体现于STL算法更加容易，也更加容易学习了(可读性更高)。
下面将以for_each为例，讲述lambda带来的便捷。
#include <vector>
#include <algorithm>
using namespace std;
vector<int> nums;
vector<int> largeNums;
const int ubound = 10;
inline void LargeNumsFunc(int i){
if (i > ubound)
largeNums.push_back(i);
}
void Above() {
// 传统的for循环
for (auto itr = nums.begin(); itr != nums.end(); ++itr) {
if (*itr >= ubound)
largeNums.push_back(*itr);
}
// 使用函数指针
for_each(nums.begin(), nums.end(), LargeNumsFunc);
// 使用lambda函数和算法for_each
for_each(nums.begin(), nums.end(), [=](int i){
if (i > ubound)
largeNums.push_back(i);
});
}
编译选项: g++ 7-3-13.cpp -c -std=c++11
这是通过基础for循环、for_each和lambda实现查找大于某个值的功能。相比for循环而言，for_each只需要关心数据起始点，并将每个元素作用到指定的操作上即可，在效率、正确性、可维护性上都具有一定优势。
而lambda较for_each而言，首先其函数内容会直接放在调用处，可阅读性更高(当然，有时也会被分离出来并命名，但通常不会太远)；其次使用函数指针很可能导致编译器不对其进行inline优化（inline对编译器而言并非强制），在循环次数较多的时候，内联的lambda和没有能够内联的函数指针可能存在着巨大的性能差别。
此外相较于仿函数(不论是自己实现还是内置仿函数)，lambda也依旧存在着不小的优势。
#include <vector>
#include <algorithm>
using namespace std;
vector<int> nums;
vector<int> largeNums;
class LNums{
public:
LNums(int u): ubound(u){}
void operator () (int i) const
{
if (i > ubound)
largeNums.push_back(i);
}
private:
int ubound;
};
void Above(int ubound) {
// 传统的for循环
for (auto itr = nums.begin(); itr != nums.end(); ++itr) {
if (*itr >= ubound)
largeNums.push_back(*itr);
}
// 使用仿函数
for_each(nums.begin(), nums.end(), LNums(ubound));
// 使用lambda函数和算法for_each
for_each(nums.begin(), nums.end(), [=](int i){
if (i > ubound)
largeNums.push_back(i);
});
}对于自己实现的仿函数，很直观的，lambda更加简洁。
而当面对更加复杂的场景时，lambda显得更加有优势：
#include <vector>
#include <algorithm>
using namespace std;
extern vector<int> nums;
void TwoCond(int low, int high) {
// 传统的for循环
for (auto i = nums.begin(); i != nums.end(); i++)
if (*i >= low && *i < high) break;
// 利用了3个内置的仿函数，以及非标准的compose2
find_if(nums.begin(), nums.end(),
compose2(logical_and<bool>(),
bind2nd(less<int>(), high),
bind2nd(greater_equal<int>(), low)));
// 使用lambda函数
find_if(nums.begin(), nums.end(), [=](int i) {
return i >= low && i < high;
});
}这里我们需找到vector nums中第一个值介于[low, high)间的元素，可以看到内置仿函数变得异常复杂。
