C++11常用的一部分新特性

统一的列表初始化

｛｝初始化

C++11扩大了用大括号括起的列表(初始化列表)的使用范围，使其可用于所有的内置类型和用户自
定义的类型，使用初始化列表时，可添加等号(=)，也可不添加。

#include
using namespace std;
int main()
{
	int arr1[] = { 1,2,3,4,5,6 };
	int arr2[]{ 1,2,3,4,5,6 };
	for (auto e : arr1)
	{
		cout << e << " ";
	}
	cout << endl;
	for (auto e : arr2)
	{
		cout << e << " ";
	}
	cout << endl;
	return 0;
}

#include
using namespace std;
struct Point
{
 int _x;
 int _y;
};
int main()
{
	Point* p1 = new Point[2]{ {1,1},{2,2} };
	return 0;
}

#include
using namespace std;
class Date
{
public:
	Date(int year, int month, int day)
		:_year(year)
		, _month(month)
		, _day(day)
	{
		cout << "Date(int year, int month, int day)" << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	//这三个效果是相同的
	Date d1(2023, 5, 25);
	Date d2{ 2023, 5, 25 };
	Date d3 = { 2023, 5, 25 };
	return 0;
}

也就是说这里用花括号进行初始化调用的是类的构造。
也就是说，C++11几乎可以一切都可以用花括号初始化，包括变量（但是不建议这样）。

std::initializer_list

来看下面这段代码：

#include
#include
#include
using namespace std;
int main()
{
	vector<int> arr{1, 2, 3, 4, 5, 6};//这里的初始化为什么可以随意改变元素数量呢？
	auto a = { 10,20,30 };//来看看这个花括号初始化成了什么类型
	cout << typeid(a).name() << endl;//这里拿到的是类型的字符串
	return 0;
}

这是initializer_list类型的使用文档https://cplusplus.com/reference/initializer_list/initializer_list/

这个类似一个常量数组，有两个指针指向数组的开始和结束（其实也是迭代器）。
并且这个vector可以利用这个类型进行初始化的。

其实就相当于将initializer_list类型中的数据遍历然后push_back()到vector里面。
这种类型的实用处就是：

//这里就不用初始化一个pair类型的然后在插入map中了，因为里面是匿名对象的初始化
map<string, string> str = { {"字符串","string"},{"排序","sort"} };//里面的两个小花括号也可以理解为一个pair类型的initializer_list数组

声明

auto

这个经常用，自动推导左边对象类型。
在C++98中auto是一个存储类型的说明符，表明变量是局部自动存储类型，但是局部域中定义局
部的变量默认就是自动存储类型，所以auto就没什么价值了。C++11中废弃auto原来的用法，将
其用于实现自动类型腿断。这样要求必须进行显示初始化，让编译器将定义对象的类型设置为初
始化值的类型。

decltype

关键字decltype将变量的类型声明为表达式指定的类型。

#include

using namespace std;

int main()
{
	int x = 0;
	cout << typeid(x).name() << endl;
	decltype(x) y;
	cout << typeid(y).name() << endl;

	return 0;
}

那么decltype使用的地方在哪里呢？

#include

using namespace std;
template<class T1, class T2>
void F(T1 t1, T2 t2)
{
	decltype(t1 * t2) ret = t1 * t2;//这里万一涉及到整型提升，不知道提升到哪个类型就可以自动推导，不至于丢失精度
	cout << typeid(ret).name() << endl;
	cout << ret << endl;
}
int main()
{
	F(1, 2);
	F(1, 2.2);
	return 0;
}

nullptr

这个之前也经常用。
由于C++中NULL被定义成字面量0，这样就可能回带来一些问题，因为0既能指针常量，又能表示
整形常量。所以出于清晰和安全的角度考虑，C++11中新增了nullptr，用于表示空指针。

#ifndef NULL
#ifdef __cplusplus
#define NULL   0
#else
#define NULL   ((void *)0)
#endif
#endif

STL中一些变化

新容器

array
https://legacy.cplusplus.com/reference/array/array/

这个新容器和数组的功能没什么区别，不如vector好用，比普通数组多一个越界检查的报错。


forward_list
https://legacy.cplusplus.com/reference/forward_list/forward_list/
这是个单链表。

这里的区别就是，每个节点少一个指针的大小，并且没有头插头删（并不是那么好用）

已有容器的新接口

这里以vector举例：

这四个其实就是上面的正迭代器和反迭代器，c只是为了显示是const版本的而已，看起来更容易辨别。

这个接口是缩容的接口，如果空间浪费的实在是太大，可以用一下（用时间换空间）。

还有这两个接口，与右值引用和可变模板参数有关，下面会结合这个接口讲解。

右值引用和移动语义

左值引用和右值引用

什么是左值？

左值是一个表示数据的表达式(如变量名或解引用的指针)，我们可以获取它的地址+可以对它赋值，左值可以出现赋值符号的左边，右值不能出现在赋值符号左边。
定义时const修饰符后的左值，不能给他赋值，但是可以取它的地址。左值引用就是给左值的引用，给左值取别名。

什么是右值？

右值也是一个表示数据的表达式，如：字面常量、表达式返回值，函数返回值(这个不能是左值引用返回)等等，右值可以出现在赋值符号的右边，但是不能出现出现在赋值符号的左边，右值不能取地址。
右值引用就是对右值的引用，给右值取别名。

注意：

1. 左值引用只能引用左值，不能引用右值。
2. 但是const左值引用既可引用左值，也可引用右值。
3. 右值引用只能右值，不能引用左值。
4. 但是右值引用可以move以后的左值。

#include
using namespace std;
int main()
{
	// 左值引用只能引用左值，不能引用右值。
	int a = 10;
	int& ra1 = a;//ra为a的别名
	//int& ra2 = 10;//编译失败，因为10是右值
	//const左值引用既可引用左值，也可引用右值。
	const int& ra3 = 10;
	const int& ra4 = a;
	int a = 10;
	int&& r2 = a;
	// error C2440: “初始化”: 无法从“int”转换为“int &&”
	// message : 无法将左值绑定到右值引用
	
	// 右值引用可以引用move以后的左值
	int&& r3 = std::move(a);
	return 0;
}

需要注意的是右值是不能取地址的，但是给右值取别名后，会导致右值被存储到特定位置，且可
以取到该位置的地址，也就是说例如：不能取字面量10的地址，但是rr1引用后，可以对rr1取地
址，也可以修改rr1。如果不想rr1被修改，可以用const int&& rr1 去引用。

右值引用使用场景和意义

左值引用最大的意义就是函数传参，返回值，减少拷贝。
那么左值引用的缺点是什么？
看下面代码：

template<class T>
T func(const int x)
{
	T ret;
	return ret;//这里ret是局部变量，出作用域就会销毁，所以是一个传值返回
}

右值引用的价值之一就是补齐这最后一块短板。

右值引用引用左值及其一些更深入的使用场景分析

来看这样一段代码：

#include
#include
#include
using namespace std;
namespace baiye
{
	class string
	{
	public:
		typedef char* iterator;
		iterator begin()
		{
			return _str;
		}
		iterator end()
		{
			return _str + _size;
		}
		string(const char* str = "")
			:_size(strlen(str))
			, _capacity(_size)
		{
			//cout << "string(char* str)" << endl;
			_str = new char[_capacity + 1];
			strcpy(_str, str);
		}
		// s1.swap(s2)
		void swap(string& s)
		{
			std::swap(_str, s._str);
			std::swap(_size, s._size);
			std::swap(_capacity, s._capacity);
		}
		// 拷贝构造
		string(const string& s)
			:_str(nullptr)
		{
			cout << "string(const string& s) -- 深拷贝" << endl;
			string tmp(s._str);
			swap(tmp);
		}
		// 赋值重载
		string& operator=(const string& s)
		{
			cout << "string& operator=(string s) -- 深拷贝" << endl;
			string tmp(s);
			swap(tmp);
			return *this;
		}
		~string()
		{
			delete[] _str;
			_str = nullptr;
		}
		char& operator[](size_t pos)
		{
			assert(pos < _size);
			return _str[pos];
		}
		void reserve(size_t n)
		{
			if (n > _capacity)
			{
				char* tmp = new char[n + 1];
				strcpy(tmp, _str);
				delete[] _str;
				_str = tmp;
				_capacity = n;
			}
		}
		void push_back(char ch)
		{
			if (_size >= _capacity)
			{
				size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
				reserve(newcapacity);
			}
			_str[_size] = ch;
			++_size;
			_str[_size] = '\0';
		}
		//string operator+=(char ch)
		string& operator+=(char ch)
		{
			push_back(ch);
			return *this;
		}
		const char* c_str() const
		{
			return _str;
		}
	private:
		char* _str;
		size_t _size;
		size_t _capacity; // 不包含最后做标识的\0
	};
}
namespace baiye
{
	baiye::string to_string(int value)
	{
		bool flag = true;
		if (value < 0)
		{
			flag = false;
			value = 0 - value;
		}
		baiye::string str;
		while (value > 0)
		{
			int x = value % 10;
			value /= 10;
			str += ('0' + x);
		}
		if (flag == false)
		{
			str += '-';
		}
		reverse(str.begin(), str.end());
		return str;
	}
}
int main()
{
	baiye::string str = baiye::to_string(-1234);
	return 0;
}

先看main函数中创建str然后调用to_string函数返回一个string类型赋值给str。
这里编译器优化就变成了拷贝构造。

这样就少了一次拷贝构造。
但如果是这种情况就无法进行优化。

那么这种情况下C++11是怎么解决问题的呢？

		// 移动构造
		string(string&& s)
			:_str(nullptr)
			, _size(0)
			, _capacity(0)
		{
			swap(s);
		}

如果传的参数是右值就会走这个函数。
注意：C++11给右值分为

纯右值（内置类型）
将亡值（自定义类型）

那么在to_string函数中返回了一个将亡值，如果在进行拷贝构造有些没必要：

那么这里在进行拷贝传值的时候就会传给移动构造函数，移动构造函数内部其实就是交换两个对象的值，反正将亡值也要销毁了，这样就不用进行深拷贝了。（深拷贝代价太大，如果深拷贝的对象是vector>效率就非常低了）

但是刚才这种情况还没有解决：

那么这里就可以再写一个移动赋值：

		// 移动赋值
		string& operator=(string&& s)
		{
			swap(s);
			return *this;
		}

总结
右值引用是间接起作用，如果右值是将亡值，那么就转移资源。

这里用vector举例：如果传进去的是右值，就会走这个接口，会提升效率。

**注意：**右值引用被引用一次之后，引用的这个别名就变成了左值。


如果不变成左值怎么传给swap。

完美转发

万能引用

#include

using namespace std;
template<class T>
void func(T&& x)//这里也可以称为引用折叠，如果传的是左值，就折叠成一个引用符号
{

}
int main()
{
	int x = 10;
	func(x);//左值也可以
	func(2);//右值也可以
	const int y = 20;
	func(y);//const左值
	func(move(y));//const右值
	return 0;
}

那么这个时候如果func函数中要去调用这四个函数，结果是怎么样的呢？

#include

using namespace std;
void Fun(int& x) { cout << "左值引用" << endl; }
void Fun(const int& x) { cout << "const 左值引用" << endl; }
void Fun(int&& x) { cout << "右值引用" << endl; }
void Fun(const int&& x) { cout << "const 右值引用" << endl; }
template<class T>
void func(T&& x)
{
	Fun(x);
}
int main()
{
	int x = 10;
	func(x);//左值
	func(2);//右值
	const int y = 20;
	func(y);//const左值
	func(move(y));//const右值
	return 0;
}

这里只会调用前两个函数，因为func中的参数x都是左值属性，这里就需要一个叫完美转发的在传参的过程中保持了 x 的原生类型属性。

新的类功能

默认成员函数

C++11 新增了两个默认成员函数：移动构造函数和移动赋值运算符重载。
针对移动构造函数和移动赋值运算符重载有一些需要注意的点如下：

如果你没有自己实现移动构造函数，且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一个。那么编译器会自动生成一个默认移动构造。默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动构造，如果实现了就调用移动构造，没有实现就调用拷贝构造。
如果你没有自己实现移动赋值重载函数，且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一个，那么编译器会自动生成一个默认移动赋值。默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动赋值，如果实现了就调用移动赋值，没有实现就调用拷贝赋值。(默认移动赋值跟上面移动构造完全类似)
如果你提供了移动构造或者移动赋值，编译器不会自动提供拷贝构造和拷贝赋值。

default与delete

强制生成默认函数的关键字default:
C++11可以让你更好的控制要使用的默认函数。假设你要使用某个默认的函数，但是因为一些原
因这个函数没有默认生成。比如：我们提供了拷贝构造，就不会生成移动构造了，那么我们可以
使用default关键字显示指定移动构造生成。

#include
using namespace std;
class Person
{
public:
	Person(const char* name = "", int age = 0)
		:_name(name)
		, _age(age)
	{}
	Person(const Person& p)
		:_name(p._name)
		, _age(p._age)
	{}
	Person(Person && p) = default;//强制生成
private:
	string _name;
	int _age;
};
int main()
{
	Person s1;
	Person s2 = s1;
	Person s3 = std::move(s1);
	return 0;
}

禁止生成默认函数的关键字delete:
如果能想要限制某些默认函数的生成，在C++98中，是该函数设置成private，并且只声明补丁
已，这样只要其他人想要调用就会报错。在C++11中更简单，只需在该函数声明加上=delete即
可，该语法指示编译器不生成对应函数的默认版本，称=delete修饰的函数为删除函数。

#include
using namespace std;
class Person
{
public:
	Person(const char* name = "", int age = 0)
		:_name(name)
		, _age(age)
	{}
	Person(const Person& p) = delete;
private:
	string _name;
	int _age;
};
int main()
{
	Person s1;
	Person s2 = s1;
	Person s3 = move(s1);
	return 0;
}

这样吴凯伦是内部和外部都无法使用这个拷贝构造函数了。

可变参数模板

参数包

这个也是为了对标C语言的可变性参数，比如printf和scanf。

#include
using namespace std;
// Args是一个模板参数包，args是一个函数形参参数包
// 声明一个参数包Args...args，这个参数包中可以包含0到任意个模板参数。
template <class ...Args>
void ShowList(Args... args)
{}
int main()
{

	return 0;
}

上面的参数args前面有省略号，所以它就是一个可变模版参数，我们把带省略号的参数称为“参数
包”，它里面包含了0到N（N>=0）个模版参数。我们无法直接获取参数包args中的每个参数的，
只能通过展开参数包的方式来获取参数包中的每个参数，这是使用可变模版参数的一个主要特
点，也是最大的难点，即如何展开可变模版参数。

如何查看参数包有几个参数呢？

#include
using namespace std;
template <class ...Args>
void ShowList(Args... args)
{
	cout << sizeof...(args) << endl;//查看参数包有几个参数
}
int main()
{
	ShowList(1);
	ShowList(1, 2.2);
	ShowList(1, 2.2, string("xxx"));

	return 0;
}

遍历参数包中的参数

递归函数方式展开参数包

#include
using namespace std;
// 递归终止函数
void ShowList()//当参数包中的参数变成0个的时候就会调用这个函数
{
	cout << endl;
}
// 展开函数
template <class T, class ...Args>
void ShowList(T value, Args... args)//第一个参数传给value，剩下的参数传给args参数包
{
	cout << value << " ";
	ShowList(args...);
}
int main()
{
	ShowList(1);//这里1传给value，然后参数包没有参数调用终止函数
	ShowList(1, 2.2);//这里第一次1传给value，2.2传给参数包，第二次2.2传给value，参数包没有值，调用终止函数
	ShowList(1, 2.2, string("xxx"));
	return 0;
}

非常的怪异。
逗号表达式展开参数包

#include
using namespace std;
template <class T>
void PrintArg(T t)
{
	cout << t << " ";
}
//展开函数
template <class ...Args>
void ShowList(Args... args)
{
	int arr[] = { (PrintArg(args), 0)... };
	cout << endl;
}
int main()
{
	ShowList(1);
	ShowList(1, 'A');
	ShowList(1, 'A', std::string("sort"));
	return 0;
}

这里的arr数组是一个辅助的作用，里面调用的是PrintArg函数，编译器自行初始化arr数组，参数包中有多少个参数数组的空间就有多大。

这里的逗号表达式只是为了初始化arr数组，初始化为0。

STL容器中的empalce相关接口函数

http://www.cplusplus.com/reference/vector/vector/emplace_back/


emplace_back是可以不传参的，那么默认用户的就是匿名构造，传入的值就是0。
那么emplace_back的意义在哪里呢？

#include
#include
using namespace std;
int main()
{
	vector<pair<int, string>>arr;
	arr.emplace_back(1, "xxx");//这里可以这样初始化(直接构造),push_back只能构造一个对象去传，当然emplace_back也可以构造一个对象传
	
	return 0;
}

其实就是一种优化，如果传入的是右值编译器可以直接优化成直接构造（移动构造或者是移动赋值都省下了），不需要任何拷贝构造或者是移动构造（如果是左值还是构造+深拷贝）。

lambda表达式

为什么要有lambda表达式

这个和仿函数有些类似。
举个例子，如果定义水果类，创建多个水果对象，那么他们分别有名字，价格，评价等等属性，如果想通过sort函数来实现对于不同对象的排序就要写很多个仿函数，非常的麻烦。

#include
#include
#include 
#include 
using namespace std; 
struct Goods
{
	string _name;// 名字
	double _price;// 价格
	int _evaluate;// 评价
	Goods(const char* str, double price, int evaluate)
		:_name(str)
		, _price(price)
		, _evaluate(evaluate)
	{}
};
struct ComparePriceLess
{
	bool operator()(const Goods& gl, const Goods& gr)
	{
		return gl._price < gr._price;
	}
};
struct ComparePriceGreater
{
	bool operator()(const Goods& gl, const Goods& gr)
	{
		return gl._price > gr._price;
	}
};
int main()
{
	vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2,3 }, { "菠萝", 1.5, 4 } };
	sort(v.begin(), v.end(), ComparePriceLess());
	sort(v.begin(), v.end(), ComparePriceGreater());
	return 0;
}

那么这个时候lambda表达式就可以上场了。

#include
#include
#include 
#include 
using namespace std; 
struct Goods
{
	string _name;// 名字
	double _price;// 价格
	int _evaluate;// 评价
	Goods(const char* str, double price, int evaluate)
		:_name(str)
		, _price(price)
		, _evaluate(evaluate)
	{}
};
struct ComparePriceLess
{
	bool operator()(const Goods& gl, const Goods& gr)
	{
		return gl._price < gr._price;
	}
};
struct ComparePriceGreater
{
	bool operator()(const Goods& gl, const Goods& gr)
	{
		return gl._price > gr._price;
	}
};
int main()
{
	vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2,3 }, { "菠萝", 1.5, 4 } };
	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._evaluate < g2._evaluate; });//按照评价排序
	return 0;
}

这是按照价格排序的结果：

这是按照评价排序：

lambda表达式的格式

lambda表达式书写格式：[capture-list] (parameters) mutable -> return-type { statement }
1.lambda表达式各部分说明

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

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

#include
using namespace std;
int main()
{
	//其实lambda就是要给可调用的对象
	auto compare = [](int x, int y) {return x > y; };//这个类型编译器认识，但是我们不认识
	cout << compare(1, 2) << endl;
	return 0;
}

那么，在外部定义的变量能在lambda表达式中使用吗？

#include
using namespace std;
int main()
{
	int a = 10;
	int b = 20;
	auto add1 = []() { return a + b; };
	return 0;
}

这里是不可以的，因为是两个不同的作用域，这个时候需要捕捉这两个变量才可以使用。

auto add1 = [a, b]() { return a + b; };

这个时候编译就通过了。
那么如果想交换两个变量呢？

#include
using namespace std;
int main()
{
	int a = 10;
	int b = 20;
	auto swap1 = [a, b]()
	{
		int c = a;
		a = b;
		b = c;
	};
	return 0;
}

这里是不允许的，如果想修改要加mutable。

	auto swap1 = [a, b]()mutable
	{
		int c = a;
		a = b;
		b = c;
	};

但是外部的a和b并没有发生改变，也就是说捕捉的对象是传值拷贝，加了一个const的变量，mutable只是让他们变成非const属性的值。
如果想改变就要这样：

#include
using namespace std;
int main()
{
	int a = 10;
	int b = 20;
	auto swap1 = [&a, &b]()//这里虽然是外部a和b的别名，但是不能修改a和b的名字，不然就不能捕捉了
	{
		int c = a;
		a = b;
		b = c;
	};
	return 0;
}

这里也无法在捕捉列表取地址。
在捕捉列表里面可以用=就是捕捉父作用域向上的变量，&是捕捉父作用域向上的变量别名。（向上就是在捕捉列表语句前面的所有变量）

#include
using namespace std;
int main()
{
	int a = 10;
	int b = 20;
	auto add1 = [=]() { return a + b; };
	auto swap1 = [&]()
	{
		int c = a;
		a = b;
		b = c;
	};
	return 0;
}

注意：这些可以进行混合捕捉，比如对父作用域向上的变量进行传值捕捉，对于某一个或者是某些进行引用捕捉。

lambda的底层

#include
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);
	// lamber
	auto r2 = [=](double monty, int year)->double {return monty * rate * year;};
	r2(10000, 2);
	return 0;
}

第一个是仿函数的反汇编，第二个是lambda表达式的反汇编，也就是说本质都是一样的调用仿函数。
并且lambda表达式的类型名字也很繁琐。

包装器

function包装器

function包装器 也叫作适配器。C++中的function本质是一个类模板，也是一个包装器。

#include
using namespace std;
template<class F, class T>
T useF(F f, T x)
{
	static int count = 0;
	cout << "count:" << ++count << endl;
	cout << "count:" << &count << endl;
	return f(x);
}
double f(double i)
{
	return i / 2;
}
struct Functor
{
	double operator()(double d)
	{
		return d / 3;
	}
};
int main()
{
	// 函数名
	cout << useF(f, 11.11) << endl;
	// 函数对象
	cout << useF(Functor(), 11.11) << endl;
	// lamber表达式
	cout << useF([](double d)->double { return d / 4; }, 11.11) << endl;
	return 0;
}

这里实例化的三分不同的函数，有没有什么办法让他不生成这么多的函数。

#include
#include
using namespace std;
int f(int a, int b)
{
	return a + b;
}
struct Functor
{
public:
	int operator() (int a, int b)
	{
		return a + b;
	}
};
int main()
{
	function<int(int, int)> f1;//第一个int是返回值，括号里面的是参数
	f1 = f;//封装到f1中
	cout << f1(1, 2) << endl;
	function<int(int, int)> f2(f);//这种方法也可以将f封装到f2中
	cout << f2(1, 2) << endl;
	function<int(int, int)> f3 = Functor();
	cout << f3(1, 2) << endl;
	/*function f4(Functor());//这里不可以，因为编译器会识别成为函数指针
	cout << f4(1, 2) << endl;*/
	function<int(int, int)> f5 = [](const int a, const int b){return a + b; };
	cout << f5(1, 2) << endl;
}

类中的成员函数也是可以包装的，但是要注意：

#include
#include
using namespace std;
class Plus
{
public:
	static int plusi(int a, int b)
	{
		return a + b;
	}
	int plusd(int a, int b)
	{
		return a + b;
	}
};
int main()
{
	//这里存入的是函数指针
	function<int(int, int)> f1 = &Plus::plusi;//静态成员函数可以不加&
	cout << f1(1, 2) << endl;
	function<int(Plus, int, int)> f2 = &Plus::plusd;//非静态成员函数必须加&，这里还要加一个参数，因为传参还有一个this指针
	cout << f2(Plus(), 1, 2) << endl;//这里是传进去一个Plus类型的对象，其实就是利用这个对象调用该成员函数而已
}

其实包装器就是对于可调用对象类型的大统一。
那么使用的场景呢？
力扣：逆波兰表达式

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        stack<int> st;
        map<string, function<int(int, int)>> opMap=
        {
            {"+",[](int x, int y){return x+y;}},
            {"-",[](int x, int y){return x-y;}},
            {"/",[](int x, int y){return x/y;}},
            {"*",[](int x, int y){return x*y;}}
        };//这里就是统一了类型
        for(auto& e:tokens)//在map中查找符号
        {
            if(opMap.count(e))
            {
                int a = st.top();
                st.pop();
                int b = st.top();
                st.pop();

                st.push(opMap[e](b, a));//找到之后就将栈中的两个值通过map中储存的包装器中的lamber表达式进行运算，这里要注意数的顺序，先去取出来的在左边，后取出来的在右边
            }
            else
            {
                st.push(stoi(e));
            }
        }
        return st.top();
    }
};

bind

std::bind函数定义在头文件中，是一个函数模板，它就像一个函数包装器(适配器)，接受一个可调用对象（callable object），生成一个新的可调用对象来“适应”原对象的参数列表。一般而言，我们用它可以把一个原本接收N个参数的函数fn，通过绑定一些参数，返回一个接收M个（M可以大于N，但这么做没什么意义）参数的新函数。同时，使用std::bind函数还可以实现参数顺序调整等操作。

// 原型如下：
template <class Fn, class... Args>
/* unspecified */ bind(Fn&& fn, Args&&... args);
// with return type (2) 
template <class Ret, class Fn, class... Args>
/* unspecified */ bind(Fn&& fn, Args&&... args);

举例：

#include
#include 
using namespace std;
int Plus(int a, int b)
{
	return a - b;
}
int main()
{
	//表示绑定函数plus 参数分别由调用 func1 的第一，二个参数指定
	function<int(int, int)> func1 = bind(Plus, placeholders::_1,placeholders::_2);//placeholders是占位对象
	cout << func1(1, 2) << endl;
	//_1代表本来的第一个参数，_2代表本来的第二个参数
	//这里调参数
	function<int(int, int)> func3 = bind(Plus, placeholders::_2, placeholders::_1);
	cout << func3(1, 2) << endl;
	return 0;
}

那么实际的作用在哪里呢？
比如包装器包装的是类的成员函数，传参的时候第一个总是类的匿名对象，写起来很麻烦。

#include
#include 
using namespace std;
class Sub
{
public:
	int sub(int a, int b)
	{
		return a - b;
	}
};
int main()
{
	function<int(int, int)> func1 = bind(&Sub::sub, Sub(), placeholders::_1, placeholders::_2);
	cout << func1(1, 2) << endl;//这里本来是三个参数，但是第一个参数已经被绑定了，包装器的参数也不用写三个了，这里也不用传三个参数了
	return 0;
}