函数对象：lamda表达式

在需要排序时候，如何快速实现排序。C++算法库为我们提供了sort函数，其底层通过快排实现。sort函数可以传递两个参数，一个是排序排序元素起始地址，第二个是排序元素结束地址，这样传入参数，sort会默认排升序。
当你的排序方式不仅仅需要简单排升序时候，就需要用到sort的第三个参数，排序方式。下面通过实现这个排序方式来认识伪函数和lamda表达式。

仿函数：函数对象

仿函数，又称伪函数。顾名思义，它并不是真正的函数。给一个普通的类，重载一个()，就实现了伪函数的定义。

struct  classFunc
{
	int operator(/*重载运算符*/)(int a,int b /*形参列表*/)
	{
		return a + b;
	}
};

functional头文件中的函数对象

仿函数是对象不是函数，所以我们可以定义一个函数对象，然后采用函数对象实现回调。
实际上，sort()函数底层就是实现了仿函数，比如你想要排降序，就需要这样调用。

#include<iostream>
#include<algorithm>
#include<vector>
#include<functional>//greater<int>()包含在这个头文件
using namespace std;

int main()
{
	vector<int> num{ 11, 22, 50, 7, 90, 4333, 5 };
	sort(num.begin(), num.end(),greater<int>());//底层采用模板实现，所以应该指明类型
	for (int i : num)
		cout << i<<"  ";
	system("pause");
}

functional头文件中是C++语言库里实现的函数对象，常用的函数对象如下：

重载的运算符	函数对象
>	greater<T>()
<	less<T>()
>=	greater_equal<T>()
<=	less_equal<T>()

STL中排序要求的都是strict weakly ordering，也就是只能用<和>，不能用<=和>=。

自定义函数对象

当然，我们可以自己定义函数对象：

#include<iostream>
using namespace std;

struct  classFunc
{
	int operator()(int a,int b)
	{
		return a + b;
	}
};
int main()
{
	classFunc f;//定义函数对象
	cout << f(20, 40) << endl;
	system("pause");
}

自定义函数对象实现sort函数的排序方式，将物品安装价格由高到底排序，因为mygreater并不是模板类实现的函数对象，所以不需要制定参数类型。

#include<iostream>
#include<algorithm>
#include<string>
#include<vector>
using namespace std;
struct Goods{
	string name;
	double price;
};
struct mygreater{
	bool operator()(const Goods& g1, const Goods& g2)
	{
		return g1.price > g2.price;
	}
};
int main()
{
	vector<Goods> Gd{ { "苹果", 2.1 }, { "相交", 3 }, \
	{ "橙子", 2.2 }, { "菠萝", 1.5 } };
	
	sort(Gd.begin(), Gd.end(), mygreater());
	
	for (Goods& i : Gd)
		cout << i.name << ":" << i.price << endl;
	system("pause");
}

lamda表达式

我们看到函数对象写起来有些繁琐，有时候我们可能实现了这个函数对象，用一次之后就不再使用了。C++11提供了这种情况下，一种更简便的实现lamda表达式。

[capture-list] (parameters) mutable -> return-type {
 statement }

• [capture-list] : 捕捉列表，该列表总是出现在lambda函数的开始位置，编译器根据[]来判断接下来
  的代码是否为lambda函数，捕捉列表能够捕捉上下文中的变量供lambda函数使用。
• (parameters)：参数列表。与普通函数的参数列表一致，如果不需要参数传递，则可以连同()一起
  省略
• mutable：默认情况下，lambda函数总是一个const函数，mutable可以取消其常量性。 使用该修饰符时，参数列表不可省略(即使参数为空)。
• ->return-type：返回值类型。用追踪返回类型形式声明函数的返回值类型，没有返回值时此部分
  可省略。返回值类型明确情况下，也可省略，由编译器对返回类型进行推导。
• {statement}：函数体。在该函数体内，除了可以使用其参数外，还可以使用所有捕获到的变量。

注意： 在lambda函数定义中，参数列表和返回值类型都是可选部分，而捕捉列表和函数体可以为空。因此C++11中最简单的lambda函数为：[]{}; 该lambda函数不能做任何事情。

#include<iostream>
using namespace std;
int main()
{
	int a = 10, b = 20;
	auto Func = [&]()mutable ->int{
		int c = a;
		a = b;
		b = c;
		return a + b;
	};
	cout << a << endl << b << endl << Func() << endl;
	system("pause");
}

通过上述例子可以看出，lambda表达式实际上可以理解为无名函数，该函数无法直接调用，如果想要直接调用，可借助auto将其赋值给一个变量。

注意：

1. 父作用域指包含lambda函数的语句块
2. 语法上捕捉列表可由多个捕捉项组成，并以逗号分割。
   比如：
   [=, &a, &b]：以引用传递的方式捕捉变量a和b，值传递方式捕捉其他所有变量
   [&，a, this]：值传递方式捕捉变量a和this，引用方式捕捉其他变量
3. 捕捉列表不允许变量重复传递，否则就会导致编译错误。 比如：[=, a]：=已经以值传递方式捕捉了所有变量，捕捉a重复。
4. 在块作用域以外的lambda函数捕捉列表必须为空。
5. 在块作用域中的lambda函数仅能捕捉父作用域中局部变量，捕捉任何非此作用域或者非局部变量都会导致编译报错。
6. lambda表达式之间不能相互赋值，即使看起来类型相同。

同样是物品安装价格排降序，使用lamda表达式实现：

#include<iostream>
#include<algorithm>
#include<string>
#include<vector>
using namespace std;
struct Goods{
	string name;
	double price;
};

int main()
{
	vector<Goods> Gd{ { "苹果", 2.1 }, { "相交", 3 }, \
	{ "橙子", 2.2 }, { "菠萝", 1.5 } };

	sort(Gd.begin(), Gd.end(), [](const Goods& g1, const Goods&g2)\
	{return g1.price > g2.price; });

	for (Goods& i : Gd)
		cout << i.name << ":" << i.price << endl;
	system("pause");
}

lamda表达式和函数对象

#include<iostream>
using namespace std;

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);
	// lamda表达式
	auto r2 = [=](double monty, int year)->double{return monty*rate*year; };
	r2(10000, 2);
	system("pause");
	return 0;
}

实际在底层编译器对于lambda表达式的处理方式，完全就是按照函数对象的方式处理的，即：如果定义了一个lambda表达式，编译器会自动生成一个类，在该类中重载了operator()。