lambda表达式
在C++98中，如果想要对一个数据集合中的元素进行排序，可以使用std::sort方法。比如说，我想在某宝买一件商品，我想买该商品价格最便宜的哪一个，这就需要对价格排升序；我如果想买性价比最高的，就需要按照综合进行排降序...
但随着C++语法的发展，有人开始觉得上面的写法太复杂了，每次为了实现一个algorithm算法，都要重新去写一个类(仿函数)，如果每次比较的逻辑不一样，还要去实现多个类，特别是相同类的命名，这些都给编程者带来了极大的不便。因此，在C++11语法中引入了lambda表达式。
lambda表达式的语法
lambda表达式书写格式：
[capture-list] (parameters) mutable -> return-type { statement }
- [capture-list] : 捕捉列表，该列表总是出现在lambda函数的开始位置，编译器根据[ ]来判断接下来的代码是否为lambda函数，捕捉列表能够捕捉上下文中的变量供lambda函数使用。
- (parameters)：参数列表。与普通函数的参数列表一致，如果不需要参数传递，则可以连同()一起省略
- mutable：默认情况下，lambda函数总是一个const函数，mutable可以取消其常量性。使用该修饰符时，参数列表不可省略(即使参数为空)。
- ->returntype：返回值类型。用追踪返回类型形式声明函数的返回值类型，没有返回值时此部分可省略。返回值类型明确情况下，也可省略，由编译器对返回类型进行推导。
- {statement}：函数体。在该函数体内，除了可以使用其参数外，还可以使用所有捕获到的变量。
在lambda函数定义中，参数列表和返回值类型都是可选部分，而捕捉列表和函数体可以为空。因此C++11中最简单的lambda函数为：[]{}; 该lambda函数不能做任何事情。
从某种程度上说，lambda函数是一个匿名函数对象。为什么？匿名函数的构成不就是返回值、参数列表和函数体吗，这三种东西在lambda同样存在。
// 见一见lambda表达式
int main()
{
auto add = [](int x, int y)->int {return x + y; };
cout << add(10, 20) << endl; //像函数一样调用
// 下面代码中的()->int可省略
// 无参数可省略
// 返回值类型可自动推导，可省略(建议不要省略)
auto func = []//()->int
{
cout << "hello world" << endl;
return 0;
}
return 0;
}捕捉列表的说明
捕捉列表描述了上下文中那些数据可以被lambda使用，以及使用的方式传值还是传引用。
[var]：表示值传递方式捕捉变量var
[=]：表示值传递方式捕获所有父作用域中的变量(包括this)
[&var]：表示引用传递捕捉变量var
[&]：表示引用传递捕捉所有父作用域中的变量(包括this)
[this]：表示值传递方式捕捉当前的this指针
int main()
{
// 传值捕捉的本质是一种拷贝，并且默认被const修饰，
// mutable相当于去掉了const属性，使该值可以被修改，
// 但是修改了不会影响外面捕捉的值，因为这是一种拷贝。
int a = 10, b = 20;
auto swap2 = [a, b]()mutable
{
int tmp = a;
a = b;
b = tmp;
};
swap2();
return 0; // 输出结果：a = 10, b = 20
}所以如果要想修改变量的值，需要使用引用传递捕捉：
int main()
{
// 传引用捕捉默认不是const，所以不需要mutable
int a = 10, b = 20;
auto swap3 = [&a, &b]()
{
int tmp = a;
a = b;
b = tmp;
};
swap3();
return 0; // 输出结果:a = 20, b = 10
}还有一种捕捉方式，叫做混合捕捉
// 混合捕捉
// 所有值以传引用的方式捕捉，d以传值的方式捕捉
auto func2 = [&, d]
{
a++;
b++;
c++;
//d++;
int ret = a + b + c + d;
return ret;
};
// 所有值以传值的方式捕捉，d以传引用的方式捕捉
auto func2 = [=, &d]
{
//a++;
//b++;
//c++;
d++;
int ret = a + b + c + d;
return ret;
};函数对象(仿函数)与lambda表达式
先来看一段代码
class Rate
{
public:
Rate(double rate) : _rate(rate){}
double operator()(double money, int year)
{
return money * _rate * year;
}
private:
double _rate;
};
int main()
{
// 函数对象(仿函数)
double rate = 0.03;
Rate r1(rate);
cout << r1(10000, 2) << endl; // 调用仿函数
// lambda
auto r2 = [rate](double money, int year)->double
{
return money * rate * year;
};
cout << r2(10000, 2) << endl; // 调用lambda
return 0;
}上述代码的输出结果r1和r2都等于600。仔细观察上述代码不难发现r1和r2的调用方式都是完全相同的，函数对象将rate作为其成员变量，在定义对象时给出初始值，lambda表达式通过捕获列表可以直接将该变量捕获到。在语法层，我们看到他们的实现代码完全不同，但是在其底层，他们都是仿函数。请看下图：
