在C++98中，如果想对一个数据集合中的元素排序，可以使用std::sort。
//仿函数
struct Greater1
{
bool operator()(const int& a, const int& b)
{
return a > b;
}
};
//比较函数
bool g2(const int& a, const int& b)
{
return a > b;
}
int main1()
{
int arry[] = { 1,5,3,7,8,9,0,2,4,6 };
//默认按照小于比较，排除来是升序
std::sort(arry, arry + sizeof(arry) / sizeof(arry[0]));
//如果需要降序，需要改变元素比较规则
std::sort(arry, arry + sizeof(arry) / sizeof(arry[0]), Greater1());
Greater1 g1;
//g1(1, 2);//这里g1是一个仿函数对象，调用它的operator()来实现的
//g2(1, 2);//这里g2是一个函数指针，调用它指向的函数
//他们是完全不同的对象，但用起来是一样的。
std::sort(arry, arry + sizeof(arry) / sizeof(arry[0]), g1);
std::sort(arry, arry + sizeof(arry) / sizeof(arry[0]), g2);
return 0;
}
如果待排序的元素类型为自定义类型，则需要定义排序时的比较规则。
struct Goods
{
string _name;//名字
double _price;//价格
int _num;//数量
Goods(const string& name, const double& price,const int& num)
:_name(name)
,_price(price)
,_num(num)
{ }
};
struct ComparePriceLess
{
bool operator()(const Goods& g1, const Goods& g2)
{
return g1._price < g2._price;
}
};
struct CompareNumLess
{
bool operator()(const Goods& g1, const Goods& g2)
{
return g1._num < g2._num;
}
};
struct CompareNameLess
{
bool operator()(const Goods& g1, const Goods& g2)
{
return g1._name < g2._name;
}
};
//struct ComparePriceGreater();
//struct CompareNumLGreater();
//...
int main()
{
vector<Goods> v = { {"苹果",3.5,2},{"香蕉",4.2,3},{"橙子",2.3,6} };
sort(v.begin(), v.end(), ComparePriceLess());
sort(v.begin(), v.end(), CompareNumLess());
sort(v.begin(), v.end(), CompareNameLess());
//sort(v.begin(), v.end(), ComparePriceGreater());
//sort(v.begin(), v.end(), CompareNumGreater());
//sort(v.begin(), v.end(), CompareNameGreater());
return 0;
}
每次实现一个比较算法，就要写一个类，如果比较逻辑不同，还要去写多个类，尤其是像同类的命名，都带来了很大的麻烦。
因此C++11提出了Lambda表达式。
lambda表达式语法
lambda表达式书写格式：
lambda表达式各部分说明：
- [capture-list]：捕捉列表。捕捉同一作用域中的对象供lambda函数使用。捕获方式可以是按值捕获（使用
=）或按引用捕获（使用&），也可以显式地指定要捕获的变量（例如[x, &y]）。如果捕获列表为空，则可以使用[]。 - (parameters)：参数列表。与普通函数列表一致，如果不需要传递参数，则连同()可以一起省略。
- mutable：默认情况下，lambda函数总是const函数，multable可以取消其常量属性。使用该修饰符时，参数列表不能省略，即使参数为空。
- ->return-type：返回值类型，可以省略。如果省略，编译器会根据函数体的返回语句自动推导返回类型（称为返回类型推导）。
- statement：函数体。除了可以使用其内部参数外，还可以使用其捕获到的变量。
注意：
在lambda函数定义中，参数列表和返回值类型都是可选部分，而捕捉列表和函数体部分可以为空，因此，最简单的lambda函数为：[]{ }；该函数不能做任何事情。
lambda表达式使用
int main()
{
int a = 1;
int b = 2;
//这就是一个a+b的lambda表达式
[a, b]()->int {return a + b; };
[a, b]() {return a + b; };//返回值类型可以省略，由编译器推导
//实现a+b
//不捕捉
auto add1 = [](int x, int y)->int {return x + y; };
cout << add1(a, b) << endl;
//按值直接捕捉a、b
auto add2 = [a, b]()->int {return a + b; };
cout << add2() << endl;
//按值捕捉所有变量
auto add3 = [=]()->int {return a + b; };
cout << add3() << endl;
//实现a、b的交换
//不捕捉
auto swap1 = [](int& x, int& y) {int z = x; x = y; y = z; };
swap1(a, b);
cout << a << " " << b << endl;
//按引用直接捕捉a、b
auto swap2 = [&a, &b]() {int c = a; a = b; b = c; };
swap2();
cout << a << " " << b << endl;
//按引用捕捉所有变量
auto swap3 = [&]() {int c = a; a = b; b = c; };
swap3();
cout << a << " " << b << endl;
//mutable用法
//auto func1 = [a, b]() {a = b; };//error。错误信息：表达式必须是可修改的左值。
auto func2 = [a, b]()mutable { a = b; };//加mutable修饰符取消了a、b的常量属性。
return 0;
}
可以看到lambda表达式实际就是一个匿名函数，没有名字，调用时，可以使用auto将其赋值给一个对象。
捕获列表说明
捕捉列表描述了上下文中那些数据可以被lambda使用，以及使用的方式传值还是传引用。
- [var]：按值捕捉变量var
- [=]：按值捕捉所有父作用域中的变量(包括this)
- [&var]：按引用捕捉变量var
- [&]：按引用捕捉所有父作用域中的变量(包括this)
- [this]：按值捕捉当前的this指针
注意：
-
父作用域指包含lambda函数的语句块。
- 语法上捕捉列表可由多个捕捉项组成，并以逗号分割。
比如：[=, &a, &b]：按引用捕捉变量a和b，按值捕捉其他所有变量 ，[&，a, this]：按值捕捉变量a和this，按引用捕捉其他所有变量。
- 捕捉列表不允许变量重复传递，否则就会导致编译错误。
比如：[=, a]：=已经以值传递方式捕捉了所有变量，捕捉a重复。
- 在块作用域以外的lambda函数捕捉列表必须为空。
在块作用域中的lambda函数仅能捕捉父作用域中局部变量，捕捉任何非此作用域或者
非局部变量都会导致编译报错。
- lambda表达式之间不能相互赋值，即使看起来类型相同。
函数对象与lambda表达式
函数对象，又称为仿函数，是一种重载了函数调用运算符（operator()）的类对象。这使得对象可以像普通函数一样被调用。
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.32;
Rate r1(rate);
r1(10000, 2);
// lamber
auto r2 = [=](double monty, int year)->double {return monty * rate * year; };
r2(10000, 2);
return 0;
}
从使用方式上来看，函数对象与lambda表达式完全一样。
函数对象将rate作为其成员变量，lambda表达式通过捕获列表可以直接将该变量捕捉到。
lambda表达式底层原理
实际底层编译器对于lambda表达式处理方式，完全就是按照函数对象的方式处理的，如果定义了一个lambda表达式，编译器会自动生成一个类，并重载operator()。
再来看使用lambda表达式实现的自定义类型的比较：
int main()
{
vector<Goods> v = { {"苹果",3.5,2},{"香蕉",4.2,3},{"橙子",2.3,6} };
sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {return g1._price > g2._price; });
sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {return g1._price < g2._price; });
sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {return g1._num > g2._num; });
sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {return g1._num < g2._num; });
sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {return g1._name > g2._name; });
sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {return g1._name < g2._name; });
return 0;
}
可以看到，使用lambda表达式使代码可读性非常高。
