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，所以不需要mutableint 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;		// 调用仿函数// lambdaauto r2 = [rate](double money, int year)->double {return money * rate * year;};cout << r2(10000, 2) << endl;		// 调用lambdareturn 0;
}

上述代码的输出结果r1和r2都等于600。仔细观察上述代码不难发现r1和r2的调用方式都是完全相同的，函数对象将rate作为其成员变量，在定义对象时给出初始值，lambda表达式通过捕获列表可以直接将该变量捕获到。在语法层，我们看到他们的实现代码完全不同，但是在其底层，他们都是仿函数。请看下图：