前言

在显示生活中，我们在用手机购物时。总是可以在页面上看到下面这样的选项。

我们知道底层这是通过排序来完成的，但是当我们实现时，要写多个排序算法，写多个仿函数来实现不同变量的比较。

比如下面代码：

struct CompareNameSmall;
struct CompareNameBig;
struct ComparePriceSmall;
struct ComparePriceBig;class Goods{friend struct CompareNameSmall;friend struct CompareNameBig;friend struct ComparePriceSmall;friend struct ComparePriceBig;private:string _name;double _price;
public:Goods(string name, double price):_name(name),_price(price){}};//仿函数
struct CompareNameSmall{bool operator()(const Goods& g1, const Goods& g2){return g1._name < g2._name;}
};
struct CompareNameBig{bool operator()(const Goods& g1, const Goods& g2){return g1._name > g2._name;}
};
struct ComparePriceSmall{bool operator()(const Goods& g1, const Goods& g2){return g1._price < g2._price;}
};
struct ComparePriceBig{bool operator()(const Goods& g1, const Goods& g2){return g1._price > g2._price;}
};int main(){Goods gds[] = { { "苹果", 2.5 }, { "香蕉", 3.0 }, { "梨", 3.5 } };sort(gds, gds + (sizeof(gds) / sizeof(gds[0])), CompareNameSmall());sort(gds, gds + (sizeof(gds) / sizeof(gds[0])), CompareNameBig());sort(gds, gds + (sizeof(gds) / sizeof(gds[0])), ComparePriceSmall());sort(gds, gds + (sizeof(gds) / sizeof(gds[0])), ComparePriceBig());system("pause");return 0;
}

随着C++的发展，人们开始觉得上面的写法太复杂了。每次为了实现一个比较算法，都需要重新定义一个类，如果每次的比较逻辑不一样，还要实现多个类，特别是在相同类的命名上。并且如果不能达到见名知义，我们还得去找对应的仿函数，才能知道它的功能，这给编程者带来了极大的不便。

因此在C++11语法中出现了lambda表达式。

一.lambda表达式用法

class Goods{public:string _name;double _price;Goods(string name, double price):_name(name), _price(price){}};int main(){Goods gds[] = { { "苹果", 2.5 }, { "香蕉", 3.0 }, { "梨", 3.5 } };//使用lambda表达式sort(gds, gds + (sizeof(gds) / sizeof(gds[0])), [](const Goods& g1, const Goods& g2)->bool{return g1._name < g2._name; });sort(gds, gds + (sizeof(gds) / sizeof(gds[0])), [](const Goods& g1, const Goods& g2)->bool{return g1._name > g2._name; });sort(gds, gds + (sizeof(gds) / sizeof(gds[0])), [](const Goods& g1, const Goods& g2)->bool{return g1._price < g2._price; });sort(gds, gds + (sizeof(gds) / sizeof(gds[0])), [](const Goods& g1, const Goods& g2)->bool{return g1._price > g2._price; });system("pause");return 0;
}

可以实现和上面一样的效果。虽然一样要写这么多函数，但是不需要面临去定义很多类和命名问题，并且不需要在去找函数。

但是我们发现lambda表达式的格式还是很奇怪的，下面来介绍一下lambda表达式的写法。

二.lambda表达式语法

lambda表达式书写格式：[捕捉列表](参数)mutable—>返回值类型{ 函数体 }

[捕捉列表]：该列表总是出现在lambda表达式的起始位置，编译器根据[]来判断接下来的代码是否为lambda表达式，捕捉列表能够捕捉当前作用域中的变量，供lambda函数使用。
- [val]：表示以传值方式捕捉变量val
- [=]：表示以传值方式捕捉当前作用域中的变量，包括this指针。
- [&val]：表示以引用方式传递捕捉变量val。
- [&]：表示以引用方式传递捕捉当前作用域中的所有变量，包括this指针。
- [this]：表示以传值方式捕捉当前的this指针。
(参数)：参数列表。与普通函数参数列表使用相同。如果不需要传递参数，可以连同"()"一起省略。
mutable：默认情况下，lambda函数总是一个const函数，捕捉的传值参数具有常性，mutable可以取消常性。使用mutable修饰符时，参数列表不能省略，即使参数为空。
—>返回值类型：返回值类型。使用追踪返回类型形式声明函数的返回值类型，没有返回值此部分可省略。返回值类型明确的情况下，也可省略，由编译器推导。
{函数体}：在函数体内除了可以使用参数外，还能使用捕捉的变量。

注意：在lambda表达式中，参数列表和返回值类型都可省略，而捕捉列表和函数体可以为空。所以最简单的lambda表达式为：[]{}，该表达式不能做任何事。

int main(){//最简单的lambda表达式[]{};//捕捉当前作用域的变量，没有参数，编译器推导返回值类型。int a = 1;int b = 2;[=]{return a + b; };//使用和仿函数差不多auto fun1 = [&](int c){b = a + c; };fun1(10);cout << a << " " << b << endl;auto fun2 = [&](int c)->int{return a + c; };fun2(20);cout << fun2(20) << endl;//传值捕捉int x = 1;int y = 2;auto add0 = [x, y]()mutable->int{ x *= 2;//捕捉传递传值具有常性return x + y; };cout << add0() << endl;auto add1 = [&x, y]()->int{ x *= 2;//捕捉传递引用不具有常性return x + y; };cout << add1() << endl;auto add2 = [](int s, int m)->int{ s *= 2;//参数不具有常性return s + m; };system("pause");return 0;
}

从上面要注意的一点是：捕捉列表传值传递具有常性，要加mutable，传引用传递不具有常性，参数列表不具有常性。

捕捉列表的要和捕捉参数变量名相同，传值传递是当前作用域变量的拷贝。

int main(){//最简单的lambda表达式[]{};//捕捉当前作用域的变量，没有参数，编译器推导返回值类型。int a = 1;int b = 2;//auto fun1 = [x, y]()->int{return x + y; };//编译错误，要和捕捉参数名相同//传值传递是捕捉变量的拷贝，实际外面的a，b没有交换auto swap1 = [a, b]()mutable{int z = a; a = b; b = z; };swap1();//注意还需要调用cout << a << " " << b << endl;//传引用才能真正修改auto swap2 = [&a, &b]{int z = a; a = b; b = z; };swap2();cout << a << " " << b << endl;return 0;
}

注意构造完对象后，对象调用，函数才起作用。

注意点:

语法上捕捉列表可由多个捕捉项组成，并以逗号隔开。捕捉项不能重复传递，否则会导致编译错误。比如：当前作用域已经有了变量a，捕捉设为[=,a]，=已经捕捉过a了，编译时会报错。
捕捉列表只能捕捉当前作用域的局部变量，作用域以外的局部变量或者非局部变量都会报错。
lambda表达式之间不能赋值，即使看起来类型相同。

void (*PF)();
int main(){auto f1 = []{cout << "hello world" << endl; };auto f2 = []{cout << "hello world" << endl; };// 此处先不解释原因，等lambda表达式底层实现原理看完后，大家就清楚了//f1 = f2; // 编译失败--->提示找不到operator=()// 允许使用一个lambda表达式拷贝构造一个新的副本auto f3(f2);f3();// 可以将lambda表达式赋值给相同类型的函数指针PF = f2;PF();return 0;}

三.lambda表达式的原理

首先我们先来比较一下仿函数和lambda表达式

我们发现仿函数的使用和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.49;Rate r1(rate);r1(10000, 2);// lamberauto r2 = [=](double monty, int year)->double{return monty*rate*year; };r2(10000, 2);return 0;
}

通过汇编来查看lambda表达式部分：