c++ - 第19节 - c++11

目录

1.C++11简介

2.统一的列表初始化

2.1.｛｝初始化

2.2.｛｝初始化的实现

3.声明

3.1.auto

3.2.decltype

3.3.nullptr

4.范围for循环

5.智能指针

6.STL中一些变化

7.右值引用和移动语义

7.1.左值引用和右值引用

7.2.左值引用与右值引用比较

7.3.右值引用使用场景和意义

7.4.右值引用更深入的使用场景分析

7.5.完美转发

8.新的类功能

9.可变参数模板

10.lambda表达式

10.1.一个例子

10.2.lambda表达式

10.3.lambda表达式语法

10.4.函数对象与lambda表达式

11.包装器

11.1.function包装器

11.2.bind

---

1.C++11简介

c++11简介：

在2003年C++标准委员会曾经提交了一份技术勘误表(简称TC1)，使得C++03这个名字已经取代了C++98称为C++11之前的最新C++标准名称。不过由于C++03(TC1)主要是对C++98标准中的漏洞进行修复，语言的核心部分则没有改动，因此人们习惯性的把两个标准合并称为C++98/03标准。从C++0x到C++11，C++标准10年磨一剑，第二个真正意义上的标准珊珊来迟。相比于C++98/03，C++11则带来了数量可观的变化，其中包含了约140个新特性，以及对C++03标准中约600个缺陷的修正，这使得C++11更像是从C++98/03中孕育出的一种新语言。相比较而言，C++11能更好地用于系统开发和库开发、语法更加泛化和简单化、更加稳定和安全，不仅功能更强大，而且能提升程序员的开发效率，公司实际项目开发中也用得比较多，所以我们要作为一个重点去学习。C++11增加的语法特性篇幅非常多，我们这里没办法一一讲解，所以本节课程主要讲解实际中比较实用的语法。

c++11官网介绍： C++11 - cppreference.com

小故事：

1998年是C++标准委员会成立的第一年，本来计划以后每5年视实际需要更新一次标准，C++国际标准委员会在研究C++03的下一个版本的时候，一开始计划是2007年发布，所以最初这个标准叫C++07。但是到06年的时候，官方觉得2007年肯定完不成C++07，而且官方觉得2008年可能也完不成。最后干脆叫C++0x。x的意思是不知道到底能在07还是08还是09年完成。结果2010年的时候也没完成，最后在2011年终于完成了C++标准。所以最终定名为C++11。

---

2.统一的列表初始化

2.1.｛｝初始化

在C++98中，标准允许使用花括号{}对数组或者结构体元素进行统一的列表初始值设定。比如：

struct Point
{
	int _x;
	int _y;
};
int main()
{
	int array1[] = { 1, 2, 3, 4, 5 };
	int array2[5] = { 0 };
	Point p = { 1, 2 };
	return 0;
}

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

struct Point
{
	int _x;
	int _y;
};
int main()
{
	int x1 = 1;   //c++98
	int x2 = { 1 };   //c++11
	int x3{ 1 };   //c++11

	int array1[] = { 1, 2, 3, 4, 5 };   //c++98
	int array2[]{ 1, 2, 3, 4, 5 };   //c++11
	int array3[5] = { 0 };   //c++98
	int array4[5]{ 0 };   //c++11

	Point p = { 1, 2 };   //c++98
	Point p{ 1, 2 };   //c++11

	// C++11中列表初始化也可以适用于new表达式中
	int* pa1 = new int(0);   //c++98，c++98new空间只支持new一个数据空间并初始化
	int* pa2 = new int[4]{ 0 };   //c++11，c++11new空间支持直接对多个new数据空间初始化
	int* pa3 = new int[4]{ 1,2,3,4 };   //c++11，c++11new空间支持直接对多个new数据空间初始化

	return 0;
}

创建对象时也可以使用列表初始化方式调用构造函数初始化

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(2022, 1, 1);   //c++98
	// C++11支持的列表初始化，这里会调用构造函数初始化
	Date d2 = { 2022, 1, 3 };   //c++98
	Date d3{ 2022, 1, 2 };   //c++11

	Date* p1 = new Date(1, 2, 3);   //c++98，c++98new空间只支持new一个数据空间并初始化
	Date* p2 = new Date[3]{ {2022,1,1}, {2022,1,1} ,{2022,1,1} };   //c++11，c++11new空间支持直接对多个new数据空间初始化

	return 0;
}

注：其实c++11支持{}初始化本质上是为了支持new[]的多数据初始化和容器的多数据初始化。

创建容器对象时也可以使用列表初始化方式进行初始化

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()
{
	vector<int> v1 = { 1, 2, 3, 4, 5 };
	vector<int> v2 { 1, 2, 3, 4, 5 };
	vector<Date> v3 = { { 2022, 1, 1 }, { 2022, 1, 1 }, { 2022, 1, 1 } };
	list<int> lt1{ 1, 2, 3 };
	set<int> s1{ 3, 4, 5, 6, 3 };
	map<string, string> dict = { { "string", "字符串" }, { "sort", "排序" } };

	return 0;
}

2.2.｛｝初始化的实现

对于所有的内置类型和用户自定义的类型，编译器通过自动转换如下图所示（内置类型自动转换方式相同），这样就天然支持列表初始化方式进行初始化。

注：这里代码Date d2={2022,1,3}是一种隐式类型的转换（隐式类型的转换是针对单参数的构造函数，这里虽然不是单参数的构造函数但是数据用{}括起来可以认为整体是单参数的），编译器首先利用{2022,1,3}构造一个Date类型的临时对象，然后用该临时对象拷贝构造给d2，编译器进行优化会直接调用Date的构造函数使用{2022,1,3}对d2进行构造。

对于STL库中的容器类型，c++11可以使用列表初始化方式对容器对象进行初始化，其实现是借助c++11新增容器initializer_list。

initializer_list类的文档介绍：initializer_list - C++ Reference (cplusplus.com)

我们使用的{}初始化列表会被编译器识别成initializer_list，{}初始化列表里面的常量内容会存储在容器initializer_list中，如下图一所示。initializer_list容器中有迭代器，initializer_list中的迭代器只能读不能写，如下图二所示，initializer_list容器中begin和end函数返回的是const修饰的指针类型，通过迭代器可以读取initializer_list容器中的数据，如下图三所示。

c++11中，STL库的各种容器中新增了一个参数类型为initializer_list的构造函数，如下图所示分别是vector、map中该新增的构造函数，各类容器在该新增的构造函数中接收initializer_list容器中的数据也就是{}初始化列表中的数据进行初始化工作。

容器中数据初始化工作一般可分为两步，首先创建空间，然后通过迭代器遍历构造函数的initializer_list类型形参对象数据，每个数据进行insert或push_back插入操作即可。vector中该构造函数初始化工作的实现代码如下图所示。

注：

1.这里vector<int> v1={1,2,3,4}可以认为是隐式类型的转换，先通过{1,2,3,4}调用initializer_list版本的构造函数构造了一个vector对象，然后通过该对象拷贝构造给v1对象，编译器优化成直接用{1,2,3,4}对v1进行构造。

2.如下图所示，这里的代码v1={10,20,30}也是隐式类型的转换，首先通过{1,2,3,4}调用initializer_list版本的构造函数构造了一个vector对象，然后通过该对象调用赋值运算符重载函数赋值给v1对象。

3.这里我们可以看出只需要给容器的构造函数增加一个参数类型为initializer_list的构造函数，构造函数内进行开空间+数据插入的初始化工作，即可实现容器的{}初始化功能。

补充内容：STL库中每个容器的插入函数也有参数类型为initializer_list的版本，如下图一所示，那么我们使用插入函数一次就可以插入多个数据，如下图二所示。

---

3.声明

c++11 提供了多种简化声明的方式，尤其是在使用模板时。

3.1.auto

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

int main()
{
	int i = 10;
	auto p = &i;
	auto pf = strcpy;
	cout << typeid(p).name() << endl;
	cout << typeid(pf).name() << endl;

	map<string, string> dict = { {"sort", "排序"}, {"insert", "插入"} };
	//map<string, string>::iterator it = dict.begin();
	auto it = dict.begin();

	return 0;
}

3.2.decltype

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

3.3.nullptr

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

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

---

4.范围for循环

范围for我们在前面的博客中已经进行了详细的讲解（参考博客c++入门），这里就不再赘述。

---

5.智能指针

智能指针部分内容较多，后面会专门写一个博客来介绍智能指针。

---

6.STL中一些变化

新容器：

用橘色圈起来是C++11中新增的几个新容器，但是实际最有用的是unordered_map和

unordered_set。这两个我们前面已经进行了详细的讲解，array（前面讲过，与静态数组相似）和forward_list（单链表）大家了解一下即可。

容器中的一些新方法：

如果我们再细细去看会发现基本每个容器中都增加了一些C++11的方法，但是其实很多都是用得比较少的。

比如提供了cbegin和cend方法返回const迭代器等等，但是实际意义不大，因为begin和end也是可以返回const迭代器的，这些都是属于锦上添花的操作。

实际上C++11更新后，每个容器的插入函数接口都新增了右值引用的版本，如下图所示。

这些容器的插入函数新增的右值引用版本到底意义在哪？网上都说他们能提高效率，他们是如何提高效率的？下面第7节右值引用和移动语义部分我们会进行解答。

---

7.右值引用和移动语义

7.1.左值引用和右值引用

传统的C++语法中就有引用的语法，而C++11中新增了的右值引用语法特性，所以从现在开始我们之前学习的引用就叫做左值引用。 无论左值引用还是右值引用，都是给对象取别名。

什么是左值？什么是左值引用？

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

int main()
{
	// 以下的p、b、c、*p都是左值
	int* p = new int(0);
	int b = 1;
	const int c = 2;

	// 以下几个是对上面左值的左值引用
	int*& rp = p;
	int& rb = b;
	const int& rc = c;
	int& pvalue = *p;

	return 0;
}

什么是右值？什么是右值引用？

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

int main()
{
	double x = 1.1, y = 2.2;

	// 以下几个都是常见的右值
	10;
	x + y;
	fmin(x, y);

	// 以下几个都是对右值的右值引用
	int&& rr1 = 10;
	double&& rr2 = x + y;
	double&& rr3 = fmin(x, y);

	// 这里编译会报错：“=”: 左操作数必须为左值。即右值不能被赋值
	10 = 1;
	x + y = 1;
	fmin(x, y) = 1;

	//这里编译会报错：'&'要求左值。即不能对右值取地址
	cout << &10 << endl;
	cout << &(x+y) << endl;
	cout << &fmin(x, y) << endl;

	return 0;
}

左值和右值的快速判断：左值可以取地址，右值不能取地址

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

注：右值引用int&& rr1=10，其中10是右值，但是rr1因为可以取地址，rr1是左值。

int main()
{
	double x = 1.1, y = 2.2;
	int&& rr1 = 10;
	const double&& rr2 = x + y;
	
	rr1 = 20;
	cout << &rr1 << endl;

	rr2 = 5.5;  //报错
	cout << &rr2 << endl;

	return 0;
}

7.2.左值引用与右值引用比较

左值引用总结：

1. 左值引用只能引用左值，不能引用右值。

2. 但是const左值引用既可引用左值，也可引用右值。

int main()
{
	// 左值引用只能引用左值，不能引用右值。
	int a = 10;
	int& ra1 = a;    //ra1为a的别名  
	//int& ra2 = 10;   // 编译失败，因为10是右值
	
	// const左值引用既可引用左值，也可引用右值。
	const int& ra3 = 10;
	const int& ra4 = a;
	return 0;
}

右值引用总结：

1. 右值引用只能引用右值，不能引用左值。

2. 但是右值引用可以引用move以后的左值。

int main()
{
	// 右值引用只能引用右值，不能引用左值。
	int&& r1 = 10;
	int a = 10;
	int&& r2 = a;  //报错：“初始化”: 无法从“int”转换为“int &&”，无法将左值绑定到右值引用

	// 右值引用可以引用move以后的左值
	int&& r3 = move(a);

	return 0;
}

注：按照语法，右值引用只能引用右值，但右值引用一定不能引用左值吗？因为：有些场景下，可能真的需要用右值去引用左值实现移动语义。当需要用右值引用引用一个左值时，可以通过move函数将左值转化为右值。C++11中，std::move()函数位于<utility>头文件中，该函数名字具有迷惑性，它并不搬移任何东西，唯一的功能就是将一个左值强制转化为右值引用，然后实现移动语义。

7.3.右值引用使用场景和意义

前面我们可以看到左值引用既可以引用左值和又可以引用右值，那为什么C++11还要提出右值引用呢？是不是化蛇添足呢？下面我们来看看左值引用的短板，右值引用是如何补齐这个短板的！

以string类的实现代码为例，下面的代码是我们之前学过string类的部分实现。

namespace bit
{
	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)
		{
			::swap(_str, s._str);
			::swap(_size, s._size);
			::swap(_capacity, s._capacity);
		}

		// 拷贝构造
		string(const string& s)
			:_str(nullptr)
			, _size(0)
			, _capacity(0)
		{
			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
	};
}

左值引用的使用场景：

场景一：

下面图一所示的代码func1是传值传参，传值传参需要调用拷贝构造函数，string类的拷贝构造函数要进行深拷贝，因此的效率很低。在c++中这里推荐优化成引用传参，如下图二所示是引用传参，如果func1的参数是bit::string& s那么只能接收左值，如果还想要接收右值那么如图中所示用const修饰即可。

 

场景二：

下面图一所示的string类的operator+=函数，其返回值为string是传值返回，那么需要调用拷贝构造函数进行深拷贝，因此的效率很低。在c++中这里推荐优化成传引用返回，上面string类代码实现中的operator+=函数如下图二所示是传引用返回，这样返回的是*this的别名，效率提高。

 

左值引用的短板：

在上面两个场景中使用左值引用即可解决问题，不需要使用右值引用。但是对于string类中的operator+函数和to_string函数来说，因为ret和str对象是局部的，不能引用返回，如下图一二所示。string类中的后置++函数也面临同样的问题。

在string类的operator+函数、to_string函数和后置++函数场景下，只能传值返回，左值引用解决不了。

 

右值引用和移动构造解决上面左值引用短板的问题：

右值可以分为两类：

1.纯右值：10、a+b（a和b是常量）

2.将亡值：string("111111")（匿名对象）、to_string(1234)（返回的是局部的自定义类型对象）、s1+"hello"（调用operator+函数，返回的是局部的自定义类型对象）、move(s1)（将左值的普通对象转变成右值的将亡值对象）

注：

1.将亡值都是自定义类型的对象。

2.将亡值对象都是即将被销毁的对象。

拷贝构造的时候参数要么是左值的普通的对象，要么是右值的将亡值对象。对于参数是左值的普通对象在拷贝构造的时候如果要深拷贝那么需要正常进行深拷贝操作，而对于参数是右值的将亡值对象在拷贝构造的时候如果要深拷贝，不需要再进行深拷贝，直接去剥夺将亡值对象，将将亡值对象资源进行转移即可，也就是移动构造。

移动构造本质是将参数右值的资源窃取过来，占位已有，那么就不用做深拷贝了，所以它叫做移动构造，就是窃取别人的资源来构造自己。

移动构造如下图所示，拷贝构造时编译器会调用参数最匹配的函数，如果拷贝构造函数的参数是左值，那么就去调用string(const string& s)函数，如果拷贝构造函数的参数是右值，那么就去调用string(string&& s)函数进行移动构造。string类中如果要拷贝就要进行深拷贝，对于左值普通对象，在string(const string& s)函数中进行深拷贝操作，对于右值将亡值对象，在string(string&& s)中将将亡值对象资源进行转移操作。

那么对于前面左值引用短板中的operator+函数、to_string函数和后置++函数，返回值为string传值返回需要调用拷贝构造函数，这里编译器不会调用深拷贝的拷贝构造，而是调用

移动构造，移动构造中没有新开空间没有拷贝数据，所以效率提高了，以to_string函数为例如下图所示。

注：这里可以看出使用move时要谨慎，move后对象资源可能会被转移走。

编译器的优化：

1.只有深拷贝构造，没有移动构造的版本（c++98）：

以to_string函数为例如下图所示，返回时本身应该是先将str拷贝构造一个临时变量，然后临时变量再拷贝构造ret，编译器经过优化直接用str对ret进行拷贝构造。

2.既有深拷贝构造，又有移动构造的版本（c++11）：

以to_string函数为例如下图所示，返回时本身应该是先将左值str拷贝构造一个临时变量，临时变量是一个将亡值，临时变量移动构造ret。编译器经过第一步优化，先将str转换识别成右值，然后移动构造一个临时变量，临时变量再移动构造ret。编译器经过第二步优化，先将str转换识别成右值，然后直接用str对ret进行移动构造。

除了增加右值引用的拷贝构造版本（移动构造），还应该增加右值引用的赋值运算符重载版本（移动赋值），如下图所示。

左值引用的深拷贝：拷贝构造、拷贝赋值

右值引用的深拷贝：移动构造、移动赋值

std标准库中，相比c++98，c++11中各容器都增加了右值版本的拷贝构造函数（即移动构造函数）和右值版本的赋值运算符重载函数（即移动赋值函数），以vector类为例如下图所示。

c++98中，std标准库的算法库algorithm中swap函数，是调用拷贝构造函数和赋值运算符重载函数进行交换，如下图一所示。c++11中，将swap函数移动到了std标准库的utility库中，该swap函数是调用移动构造函数和移动赋值运算符重载函数进行交换，不会再进行深拷贝的交换，如下图二所示。

因此在c++11中要交换两个容器对象，除了调用容器中配备的swap函数，调用utility库中的swap函数效率也很高，而如果一些容器没有配备swap函数，可以放心使用utility库中的swap函数。

7.4.右值引用更深入的使用场景分析

c++11的STL标准库中每个容器除了拷贝构造函数和赋值运算符重载函数增加了右值的版本（即移动拷贝和移动赋值版本），所有的插入函数，例如头插函数push_front、尾插函数push_back和插入函数insert也增加了右值的版本，以list为例如下图所示。

在左值版本的插入函数中调用的是拷贝构造，在右值版本的插入函数中调用的是移动构造，如下图一所示。如果插入内容是左值就去调用左值版本的插入函数，左值版本的插入函数内进行深拷贝，如果插入内容是右值就去调用右值版本的插入函数，右值版本的插入函数内进行资源转移。

注：

1.上面代码中对s1进行move操作然后进行拷贝构造，s1其实进行了移动构造，移动构造后s1里面的数据会被转移走。

2.如果一个左值不再使用了可以去move操作，如果一个左值还要使用就不要move操作。如果一个左值还要使用却进行了move操作，那么只要经过插入、拷贝、赋值等操作该左值里面的数据内容就会被转移走。

c++11的STL库中还新增了emplace函数，emplace函数中也使用了右值引用，各容器中每有一个插入函数就会对应有一个emplace系列函数，例如每有一个push_front函数就会有一个emplace_front函数，每有一个push_back函数就会有一个emplace_back函数，每有一个insert函数就会有一个emplace函数。

emplace系列函数中使用了模板的可变参数，可变参数模板后面会讲到，后面会详细讲解。

7.5.完美转发

模板中的&&不代表右值引用，而是万能引用，其既能接收左值又能接收右值。 模板的万能引用提供了能够同时接收左值引用和右值引用的能力，但在后续使用中会发生引用折叠，会退化成左值（右值属性丢失），如下图所示。

注：前面讲过右值引用int&& rr1=10，其中10是右值，但是rr1因为可以取地址，rr1是左值。也就是说无论是右值引用的变量接收右值还是左值引用的变量接收左值，该变量都是左值的（也就是说上图的PerfectForward函数的参数t一定是左值的），因此该变量在后续使用中都是左值属性，这就是发生引用折叠的原因。

因为模板的万能引用在后续的使用中会发生引用折叠退化成左值，那么就无法进行右值引用的一系列操作，比如：移动拷贝、移动赋值和右值版本的插入操作，如下图所示。

我们希望能够在传递过程中保持它的左值或者右值的属性, 就需要用到完美转发：

std::forward完美转发在传参的过程中保留对象原生类型属性，如下图所示，将代码Fun(t)修改成Fun(std::forward<T>(t))，那么参数t的属性就会保持给变量t传输时原数据的属性。

完美转发实际中的使用场景：

如下面代码所示，在PushBack(T&& x) 和PushFront(T&& x)函数中，必须要用代码Insert(_head, std::forward<T>(x))和Insert(_head->_next, std::forward<T>(x))来复用Insert函数，这样才能保证x保持给变量x传输时原数据的属性，才能保证PushBack或PushFront的数据如果是左值复用左值版本的Insert函数，PushBack或PushFront的数据如果是右值复用右值版本的Insert函数。

如果在PushBack(T&& x) 和PushFront(T&& x)函数中，用代码Insert(_head, x)和Insert(_head->_next, x)来复用Insert函数，那么无论给变量x传输时原数据的属性是左值还是右值，x一定是左值属性，那么PushBack或PushFront的数据无论是左值还是右值都是复用左值版本的Insert函数。

template<class T>
struct ListNode
{
	ListNode* _next = nullptr;
	ListNode* _prev = nullptr;
	T _data;
};
template<class T>
class List
{
	typedef ListNode<T> Node;
public:
	List()
	{
		_head = new Node;
		_head->_next = _head;
		_head->_prev = _head;
	}
	void PushBack(T&& x)
	{
		//Insert(_head, x);
		Insert(_head, std::forward<T>(x));
	}
	void PushFront(T&& x)
	{
		//Insert(_head->_next, x);
		Insert(_head->_next, std::forward<T>(x));
	}
	void Insert(Node* pos, T&& x)
	{
		Node* prev = pos->_prev;
		Node* newnode = new Node;
		newnode->_data = std::forward<T>(x); // 关键位置
		// prev newnode pos
		prev->_next = newnode;
		newnode->_prev = prev;
		newnode->_next = pos;
		pos->_prev = newnode;
	}
	void Insert(Node* pos, const T& x)
	{
		Node* prev = pos->_prev;
		Node* newnode = new Node;
		newnode->_data = x; // 关键位置
		// prev newnode pos
		prev->_next = newnode;
		newnode->_prev = prev;
		newnode->_next = pos;
		pos->_prev = newnode;
	}
private:
	Node* _head;
};

int main()
{
	List<bit::string> lt;
	lt.PushBack("1111");
	lt.PushFront("2222");

	return 0;
}

---

8.新的类功能

默认成员函数：

原来C++类中，有6个默认成员函数：

1. 构造函数

2. 析构函数

3. 拷贝构造函数

4. 拷贝赋值重载

5. 取地址重载

6. const 取地址重载

最后重要的是前4个，后两个用处不大。默认成员函数就是我们不写编译器会生成一个默认的。

C++11 新增了两个：移动构造函数和移动赋值运算符重载。

针对移动构造函数和移动赋值运算符重载有一些需要注意的点如下：

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

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

如果你提供了移动构造或者移动赋值，编译器不会自动提供拷贝构造和拷贝赋值。

如下图所示，这里调用的是person类默认生成的拷贝构造、移动构造和移动赋值函数，而默认生成的拷贝构造、移动构造和移动赋值函数去调用string类的拷贝构造、移动构造和移动赋值函数。

类成员变量初始化：

C++11允许在类定义时给成员变量初始缺省值，默认生成构造函数会使用这些缺省值初始化，这个我们在博客类和对象中讲过了，这里不再赘述。

强制生成默认函数的关键字default:

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

禁止生成默认函数的关键字delete:

如果能想要限制某些默认函数的生成，在C++11中，只需在该函数声明加上=delete即可，该语法指示编译器不生成对应函数的默认版本，称=delete修饰的函数为删除函数。

继承和多态中的final与override关键字：

这个我们在继承和多态章节已经进行了详细讲解，这里不再赘述。

---

9.可变参数模板

C++11的新特性可变参数模板能够让您创建可以接受可变参数的函数模板和类模板，相比

C++98/03，类模版和函数模版中只能含固定数量的模版参数，可变模版参数无疑是一个巨大的改进。然而由于可变模版参数比较抽象，使用起来需要一定的技巧，所以这块还是比较晦涩的。现阶段，我们掌握一些基础的可变参数模板特性就够我们用了，所以这里我们点到为止，以后大家如果有需要，再可以深入学习。

下面就是一个基本可变参数的函数模板：

Args是一个模板参数包，args是一个函数形参参数包

声明一个参数包Args...args，这个参数包中可以包含0到任意个模板参数。

template <class ...Args>
void ShowList(Args... args)
{}

注：

1.Args和args只是名字，名字可以随便取，如下图所示。

2.想要获取参数包中的参数个数，可以使用语法sizeof...(参数包)，如下图所示。

递归函数方式展开参数包：

递归函数方式展开参数包需要展开函数和递归终止函数，如下图所示。

首先主函数中代码ShowList(1, 'x', 1.1)调用展开函数，展开函数模板T此时对应第一个数据1，识别成int，val值对应第一个数据1，识别为1，模板参数包Args、函数形参参数包args内有两个数据待识别，此时sizeof...(args)为2，val值为1类型为int，然后ShowList(args...)递归识别后面模板参数包Args、函数形参参数包args内数据；

ShowList(args...)递归调用展开函数，展开函数模板T此时对应第二个数据'x'，识别成char，val值对应第二个数据x，识别为x，模板参数包Args、函数形参参数包args内有一个数据待识别，此时sizeof...(args)为1，val值为x类型为char，然后ShowList(args...)递归识别后面模板参数包Args、函数形参参数包args内数据；

此时模板参数包Args、函数形参参数包args内有一个数据待识别，递归终止函数是现成的一个参数值的函数，展开函数是半现成的，对于模板编译器总是会匹配参数最匹配的，因此此时会递归调用递归终止函数，递归终止函数模板T此时对应第三个数据1.1，识别成double，val值对应第三个数据1.1，识别为1.1，递归调用结束。

注：

1.将递归终止函数改成下面这种形式也是可以的，这样第一次递归调用展开函数识别T和val识别1，模板参数包Args、函数形参参数包args内有2个数据，第二次递归调用展开函数识别T和val识别'x'，模板参数包Args、函数形参参数包args内有1个数据，第三次递归调用展开函数识别T和val识别1.1，模板参数包Args、函数形参参数包args内有0个数据，第四次递归调用递归终止函数，因为此时递归终止函数的模板参数是最匹配的，递归终止函数调用完递归调用结束。

2.删除递归终止函数，将展开函数改成下面这种形式是不行的，因为上面通过递归终止函数结束是编译的时候进行的，而if(sizeof...(args)==0){return;}逻辑判断是运行时判断的，编译时不会去进行if逻辑判断。编译时当T和val识别最后一个数据，模板参数包Args、函数形参参数包args内数据个数为0时，不会判断进入if语句，而是继续往后执行再次ShowList(args...)递归调用，此时没有匹配的函数会报错。

逗号表达式展开参数包：

这种展开参数包的方式，不需要通过递归终止函数，是直接在展开函数体中展开的, printarg不是一个递归终止函数，只是一个处理参数包中每一个参数的函数。这种就地展开参数包的方式实现的关键是逗号表达式。我们知道逗号表达式会按顺序执行逗号前面的表达式。展开函数中的逗号表达式：(printarg(args), 0)，也是按照这个执行顺序，先执行

printarg(args)，再得到逗号表达式的结果0。同时还用到了C++11的另外一个特性——初始化列表，通过初始化列表来初始化一个变长数组, {(printarg(args), 0)...}将会展开成((printarg(arg1),0), (printarg(arg2),0), (printarg(arg3),0), etc... )，最终会创建一个元素值都为0的数组int arr[sizeof...(Args)]。由于是逗号表达式，在创建数组的过程中会先执行逗号表达式前面的部分printarg(args)打印出参数，也就是说在构造int数组的过程中就将参数包展开了，这个数组的目的纯粹是为了在数组构造的过程展开参数包。

注：这里也可以不用逗号表达式，将展开函数中代码int arr[] = { (PrintArg(args), 0)... }修改为int arr[] = { PrintArg(args)... }，然后给PrintArg函数加上返回值int然后return 0（这里返回值类型和返回值与数组arr的数据类型相对应），如下图所示。

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

以emplace_back为例如下面代码所示，这里使用了模板的可变参数，且每个模板参数都是万能引用。

template <class... Args>
void emplace_back(Args&&... args);

首先我们看到的emplace系列的接口，支持模板的可变参数，并且万能引用。那么相对insert和emplace系列接口的优势到底在哪里呢？

emplace系列函数因为参数是可变参数，如果容器的数据类型是pair类型，支持直接依次传pair的两个参数值，emplace拿到构建pair对象的参数后自己去创建对象。例如mylist.emplace_back(10, 'a')，emplace_back拿到数据后会在底层直接构造pair对象进行尾插，因此这种方式实际尾插前只会调用一次pair的构造函数。

下面代码mylist.push_back(make_pair(40, 'd'))中make_pair是一个函数调用会调用pair的构造函数，make_pair是传值返回，因此这种写法是调用push_back的右值版本进行尾插。这种方式实际尾插前本身要调用一次pair的构造函数调用一次移动构造，但是编译器对这种情况会进行优化，优化成只会调用一次pair的构造函数。

下面代码mylist.emplace_back(make_pair(30, 'c'))中make_pair是一个函数调用会调用pair的构造函数，make_pair是传值返回。这种方式实际尾插前要调用一次pair的构造函数调用一次移动构造。

下面代码mylist.push_back({ 50, 'e' })中{ 50, 'e' }会调用pair的构造函数隐式类型转换为pair，相当构造了一个pair类型的右值，然后调用push_back的右值版本进行尾插，因此这种方式实际尾插前要调用一次pair的构造函数调用一次移动构造。

注：在上面的场景下我们可以看到emplace和push_back除了用法上有一些区别，在效率上emplace相比于push_back会少调用一次移动构造，但移动构造效率很高，因此二者其实没有太大的区别。如果容器中的数据，其数据类型对应类中没有移动构造而只有拷贝构造（包括内置类型，其相当于只有拷贝构造），那么emplace的效率是略高于push_back的。

---

10.lambda表达式

10.1.一个例子

在C++98中，如果想要对一个数据集合中的元素进行排序，可以使用std::sort方法。

#include <algorithm>
#include <functional>
int main()
{
	int array[] = { 4,1,8,5,3,7,0,9,2,6 };

	// 默认按照小于比较，排出来结果是升序
	std::sort(array, array + sizeof(array) / sizeof(array[0]));
	// 如果需要降序，需要改变元素的比较规则
	std::sort(array, array + sizeof(array) / sizeof(array[0]), greater<int>());

	return 0;
}

如果待排序元素为自定义类型，需要用户定义排序时的比较规则如下面代码所示，随着C++语法的发展，人们开始觉得下面的写法太复杂了，如果有n个属性要排升序降序，我们要写2n个仿函数，并且每个仿函数还要根据功能的不同命名也不能相同。这些给编程者带来了极大的不便。因此，在C++11语法中出现了Lambda表达式。

#include <algorithm>
#include <functional>
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());
}

注：如下图所示，代码Goods g1={"苹果",2.1,5}是隐式类型转换，使用{"苹果",2.1,5}构造一个Good类型的临时对象，然后将临时对象移动构造给g1编译器会优化成直接使用{"苹果",2.1,5}对g1进行构造（隐式类型的转换是针对单参数的构造函数，这里虽然不是单参数的构造函数但是数据用{}括起来可以认为整体是单参数的）。这里代码vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2, 3 }, { "菠萝", 1.5, 4 } }对vector类型的v对象初始化，要一次初始化多个数据，{}初始化列表会被编译器识别成initializer_list，{}初始化列表里面的内容{ "苹果", 2.1, 5 }、{ "香蕉", 3, 4 }、 { "橙子", 2.2, 3 }、 { "菠萝", 1.5, 4 } 会存储在容器initializer_list中，initializer_list类型的容器拷贝构造给vector类型的v对象，需要进行两个隐式类型的转换，第一个是将initializer_list容器里面的内容{ "苹果", 2.1, 5 }、{ "香蕉", 3, 4 }、 { "橙子", 2.2, 3 }、 { "菠萝", 1.5, 4 }调用Goods的构造函数转换成Goods类型的对象，第二个是调用vector中initializer_list版本的构造函数将initializer_list容器构造成vector类型的临时对象，然后vector类型的临时对象移动构造给v，编译器会优化成直接使用initializer_list容器对v进行构造。

10.2.lambda表达式

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._price > g2._price; });
	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
		return g1._evaluate < g2._evaluate; });
	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
		return g1._evaluate > g2._evaluate; });

	return 0;
}

上述代码就是使用C++11中的lambda表达式来解决，可以看出lambda表达式实际是一个匿名函数。

10.3.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函数不能做任何事情。

注：

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

2.lambda表达式一般是局部的匿名函数，给局部范围内使用，也可以写到全局，如下图所示，但如果写到全局不如直接写一个普通的函数或仿函数。

2.捕获列表说明 ：

 捕捉列表描述了上下文中那些数据可以被lambda使用，以及使用的方式传值还是传引用。    

 [var]：表示值传递方式捕捉变量var

 [=]：表示值传递方式捕获所有父作用域中的变量(包括this)

 [&var]：表示引用传递捕捉变量var

 [&]：表示引用传递捕捉所有父作用域中的变量(包括this)

 [this]：表示值传递方式捕捉当前的this指针（在类的成员函数中写lambda表达式想用类的成员变量就需要获取类对象的this指针，使用[this]就可以专门捕获this指针）

注意：

a. 父作用域指包含lambda函数的语句块。

b. 语法上捕捉列表可由多个捕捉项组成，并以逗号分割。

比如：[=, &a, &b]：以引用传递的方式捕捉变量a和b，值传递方式捕捉其他所有变量

[&，a, this]：值传递方式捕捉变量a和this，引用方式捕捉其他变量

c. 捕捉列表不允许变量重复传递，否则就会导致编译错误。

比如：[=, a]：=已经以值传递方式捕捉了所有变量，捕捉a重复

d. 在块作用域以外的lambda函数捕捉列表必须为空。

e. 在块作用域中的lambda函数仅能捕捉父作用域中局部变量，捕捉任何非此作用域或者

非局部变量都会导致编译报错。

f. lambda表达式之间不能相互赋值，即使看起来类型相同 。

注：

1.在捕捉变量时，在lambda表达式中传值捕获的变量相当于使用const进行了修饰，因此在lambda表达式中不能对传值捕捉的变量进行改变。如果想在lambda表达式中对传值捕捉的变量进行改变，也就是在lambda表达式中将捕获变量修饰的const去掉，那么就加上lambda表达式的mutable部分即可。

2.在捕捉变量时，传值捕捉到的变量相当于是原本变量的一份临时拷贝，因此如下图一所示，即使加了mutable部分可以修改lambda表达式中捕获到的a、b变量了，但是修改的a、b变量只是一份临时拷贝，并不是原本的a、b变量。如果想捕捉变量然后进行交换，我们可以使用传引用捕捉的方式，如下图二所示。

在lambda表达式传引用捕获的变量不会使用const进行了修饰。

3.lambda表达式之间不能相互赋值，即使看起来类型相同，具体原因下一小节学习了lambda表达式的底层就能理解。允许使用一个lambda表达式拷贝构造一个新的副本，也可以将lambda表达式赋值给相同类型的函数指针，如下图所示。

4.lambda表达式和局部深度绑定，可以快速捕捉获取局部范围内的变量进行使用，可在局部范围内使用lambda表达式。

有了lambda表达式我们就可以使用lambda表达式对前面的自定义类型对象排序代码进行优化，如下图所示。

10.4.函数对象与lambda表达式

函数对象，又称为仿函数，即可以想函数一样使用的对象，就是在类中重载了operator()运算符的类对象。

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表达式完全一样。

函数对象将rate作为其成员变量，在定义对象时给出初始值即可，lambda表达式通过捕获列表可以直接将该变量捕获到。

实际在底层编译器对于lambda表达式的处理方式，完全就是按照函数对象的方式处理的，编译器层面没有lambda表达式，对于编译器来说上面代码的r1和r2变量都是仿函数对象，即如果定义了一个lambda表达式，编译器会自动生成一个类，在该类中重载了operator()。

从上图可以看出lambda表达式编译器自动生成仿函数类名称的格式为lambda_uuid，uuid是通用唯一识别码，保证在同一程序中每一次生成出来的识别码不同，这样就保证了编译器自动生成仿函数类名称不冲突。

注：

1.这里就可以理解为什么lambda表达式之间不能相互赋值，即使看起来类型相同。因为编译器自动生成仿函数类名称不会冲突，即使两个lambda表达式完全相同，生成仿函数类名称也是不同的，仿函数类名称不同那么其对象的类型也不同，因此不能相互赋值。

2.lambda表达式对象的类型是编译器自动生成仿函数类名称，在底层才能知道仿函数类的名称，因此我们使用auto来让编译器自动推lambda表达式对象的类型。

---

11.包装器

11.1.function包装器

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

那么我们来看看，我们为什么需要function呢？

ret = func(x);

上面func可能是什么呢？func可能是函数名？函数指针？函数对象(仿函数对象)？也有可能是lamber表达式对象？所以这些都是可调用的类型！如此丰富的类型，可能会导致模板的效率低下！为什么呢？我们继续往下看。

从上图运行结果可以看到三个count都是1且其地址不同，因此通过上面的程序验证，我们会发现useF函数模板实例化了三份。

包装器可以很好的解决上面的问题。

std::function在头文件<functional>中，类模板原型如下：

//展开函数
template <class T> function; 

//递归终止函数
template <class Ret, class... Args> 
class function<Ret(Args...)>;

模板参数说明：

Ret：被调用函数的返回类型

Args…：被调用函数的形参

注：

1.function包装器可以包装任何可调用对象，可调用对象有函数名、函数指针、函数对象(仿函数对象)、lamber表达式对象。

2.function包装器包装函数名或函数指针时，需要给包装器对象传函数名或函数指针。function包装器包装仿函数对象时，需要给包装器对象传仿函数对象。function包装器包装lamber表达式时，需要给包装器对象传lamber表达式对象。function包装器包装类的成员函数时，如果是静态成员函数，需要给包装器对象传静态成员函数名或静态成员函数地址，如果是普通成员函数，需要给包装器对象传普通成员函数地址。

3.类的非静态的成员函数有一个隐藏的this指针，function包装器包装的时候，被调用函数的形参Args…部分第一个参数需要是类名，包装的对象调用时第一个参数必须传类对象，因为要调用类的非静态的成员函数必须得有类对象才能调用，如下图所示。

4.function包装器对可调用对象进行包装，使得不同类型的可调用对象统一为function的包装器类型。

有了包装器，如何解决模板的效率低下，实例化多份的问题呢？

从上图运行结果可以看到三个count不再都是1且其地址相同，因此通过上面的程序验证，我们会发现useF函数模板实例化了一份。

有了包装器，前面在c++的stack和queue博客中，我们做的题目逆波兰表达式就可以进行优化，逆波兰表达式题目和优化代码如下所示。

题目描述：

题目链接：150. 逆波兰表达式求值 - 力扣（LeetCode）

原版代码：

优化代码：

这里我们使用map建立一个映射关系，将命令和对应的操作建立映射关系，建立map时要写命令和操作的类型，命令是字符串其类型是string，而操作如果我们使用仿函数，要写四个仿函数，四个仿函数类名不同，因此四个仿函数类对象类型也不同这里无法写，函数指针c++不推荐写，lamber表达式对象的类型是编译器自动生成的仿函数类名称我们并不知道，所以这里使用function包装器来统一不同类型的可调用对象，function包装器只需要确认参数和返回值类型即可，这里我们使用lamber表达式。

11.2.bind

如下图所示，如果要使用map将命令和对应的操作建立映射关系，调用对象经过function包装器进行包装后参数和返回值可能不同。比如下图的函数指针f、仿函数对象Functor()、lamber表达式[](const int a, const int b)、类的静态成员函数&Plus::plusi经过function包装器进行包装后类型都是function<int(int, int)>，而类的普通成员函数&Plus::plusd经过function包装器进行包装后类型是function<double(Plus, double, double)>。这样经过function包装器包装后虽然类型统一了都是包装器类型，但包装器参数返回值格式不统一，map中操作数据类型格式就无法明确。

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

总结：function是用来包装可调用对象，使得不同类型的可调用对象类型进行统一。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);

可以将bind函数看作是一个通用的函数适配器，它接受一个可调用对象，生成一个新的可调用对象来“适应”原对象的参数列表。

调用bind的一般形式：auto newCallable = bind(callable,arg_list);

其中，newCallable本身是一个可调用对象，arg_list是一个逗号分隔的参数列表，对应给定的callable的参数。当我们调用newCallable时，newCallable会调用callable,并传给它arg_list中的参数。

arg_list中的参数可能包含形如_n的名字，其中n是一个整数，这些参数是“占位符”，表示

newCallable的参数，它们占据了传递给newCallable的参数的“位置”，有几个占位符_n，bind函数调整后生成的新的可调用对象参数就有几个。数值n表示生成的可调用对象中参数的位置：_1为newCallable的第一个参数，_2为第二个参数，以此类推。

注：占位符_n的属于命名空间placeholders，使用时格式应为placeholders::_n。

使用bind调整适配原可调用对象参数个数：

如上面代码所示，代码func3(Plus(), 100, 200)，func3是使用Plus()匿名对象调用plusi成员函数，我们没有显式传参因此_x使用默认值2，plusi成员函数a、b参数显式的传100、200，结果为600；代码func4(100, 200)，func4是调用适配的可调用对象&Plus::plusi，可调用对象&Plus::plusi使用适配固定的Plus(10)匿名对象调用plusi成员函数，固定的匿名对象显式传参因此_x为10，plusi成员函数a、b参数显式的传100、200，结果为3000。代码func5(200)，func5是调用适配的可调用对象&Plus::plusi，可调用对象&Plus::plusi使用适配固定的Plus(10)匿名对象调用plusi成员函数，固定的匿名对象显式传参因此_x为10，plusi成员函数的a参数固定适配10，plusi成员函数的b参数显式的传200，结果为2100。

使用bind调整适配原可调用对象参数顺序：

如上面代码所示，代码func1(66, 77)显式传参66传给了函数f第一个参数a，77传给了函数f第二个参数b，a-b结果为-11。代码func2(66, 77)其中bind适配中占位符_2表示函数f第二个参数，占位符_1表示函数f第一个参数，那么66传给了占位符_2对应函数f第二个参数b，77传给了占位符_1对应函数f第一个参数a，a-b结果为11。

有了bind，如下图所示，先使用bind适配调整调用对象的参数格式，然后再使用function包装器包装，这样对于所有调用对象，类型统一了都是包装器类型，包装器参数返回值格式也统一了，map中操作数据类型格式就明确了。