【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);
	
	// 这里编译会报错：error C2106: “=”: 左操作数必须为左值
	10 = 1;
	x + y = 1;
	fmin(x, y) = 1;
	return 0;
}

需要注意的是，对右值的判断方式就是 —— 右值不可以取地址，看上方的 10、x+y、fmin(x,y) ，都是不能取地址的。

右值是不能取地址的，但是给右值取别名后，会导致右值被存储到特定位置，且可以取到该位置的地址，也就是说例如上方代中：不能取字面量10的地址，但是rr1引用后，可以对rr1取地址，也可以修改rr1。如果不想rr1被修改，可以用const int&& rr1 去引用。但是，实际中右值引用的使用场景并不在于此，这个特性也不重要。

左值引用和右值引用的比较

左值引用：

1. 左值引用只能引用左值，不能引用右值。
2. 但是 const 左值引用既可引用左值，也可引用右值。

int main()
{
	int a = 0;
	int b = 1;
	int* p = &a;

	a + b;

	// 左值引用给左值取别名
	int& ref1 = a;

	// 左值引用给右值取别名
	const int& ref2 = (a + b);

	return 0;
}

右值引用：

1. 右值引用只能右值，不能引用左值。
2. 但是右值引用可以 move 以后的左值。 （move 可以将左值转化为右值）

int main()
{
	int a = 0;
	int b = 1;
	int* p = &a;

	a + b;

	// 右值引用给右值取别名
	int&& ref3 = (a + b);

	// 右值引用给move后左值取别名
	int&& ref4 = move(a);

	return 0;
}

使用场景和意义

移动构造

如下代码，运行后从打印结果可以看出， func(a)、func(a+b) 分别调用了第一个和第二个函数，这说明右值引用在传参的过程中，可以进行更好的参数匹配，将左值和右值区分开。

void func(const int& a)
{
	cout << "void func(int& a)" << endl;
}

void func(int&& a)
{
	cout << "void func(int&& a)" << endl;
}

int main()
{
	int a = 0;
	int b = 1;
	func(a);
	func(a + b);
}

但是，右值引用的意义绝不仅仅在此。如下代码， (s1+s2) 是右值，在某些教科书上，右值又分为：

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

很明显 (s1+s2) 属于将亡值，也就是说， s1 + s2 马上就要被清理了。如果 string ret2 = (s1+s2); 依然进行深拷贝，所花费的代价太大，所以在这里可以进行资源转移 —— 把 (s1+s2) 的资源转移给 ret2 。 这样就避免深拷贝，提高效率！

int main()
{
	string s1("hello ");
	string s2("world");

	string ret1 = s1;      // s1 是左值，直接深拷贝
	string ret2 = (s1+s2); // (s1+s2) 是右值
	
	return 0;
}

我们可以用自己实现的 string 来模拟这个过程，可以让我们深刻理解。使用右值进行资源转移的拷贝，又叫移动拷贝/移动构造。

namespace simulate
{
	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)
		{
			cout << "string(const string& s) -- 深拷贝" << endl;

			string tmp(s._str);
			swap(tmp);
		}

		// 移动构造
		string(string&& s)
			:_str(nullptr)
		{
			cout << "string(string&& s) -- 移动拷贝" << endl;
			swap(s);
		}

		// 赋值重载
		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;
		}

		string operator+(char ch)
		{
			string tmp(*this);
			tmp += ch;
			return tmp;
		}

		const char* c_str() const
		{
			return _str;
		}
	private:
		char* _str;
		size_t _size;
		size_t _capacity; // 不包含最后做标识的\0
	};

	simulate::string to_string(int value)
	{
		bool flag = true;
		if (value < 0)
		{
			flag = false;
			value = 0 - value;
		}

		simulate::string str;
		while (value > 0)
		{
			int x = value % 10;
			value /= 10;

			str += ('0' + x);
		}

		if (flag == false)
		{
			str += '-';
		}

		std::reverse(str.begin(), str.end());
		return str;
	}
}



int main()
{
	simulate::string s1("hello world");

	simulate::string ret1 = s1;
	simulate::string ret2 = (s1+'!');

	simulate::string ret3 = move(s1);  // 不用 s1了，想让它的资源被转走，可以用 move() 

	return 0;
}

我们可以通过监视窗口查看，如下图绿色框内，发现确实是直接把 tmp 的资源转移给了 ret2。

C++11 的所有 STL 容器，都增加了移动构造。

---

左值引用的缺陷

首先，左值引用直接减少了拷贝：1、左值引用传参。2、左值引用传返回值。 但是，左值引用无法解决 函数内的局部变量 不能传引用返回 这个问题。那么，函数传值返回局部变量，就一定会造成拷贝。比如上方模拟 string 的代码中的 to_string() ，这就不可避免地要进行传值返回。

如下图，如果是正常情况，to_string() 返回 str，会先拷贝构造 str 到一个临时对象，然后将临时对象的值 拷贝给 ValStr。但是，我们知道编译器对连续的拷贝构造会进行优化，优化成单次的拷贝构造。这是 C++ 11 之前，编译器的优化方案。

到了 C++ 11，有了右值引用之后，就可以进行资源转移。 str 在 to_string 中，明显是左值，正常情况下，会先将 str 拷贝到一个临时对象，由于临时对象是右值，所以会进行移动构造，将资源转移给 ValStr。
但是，经过新版编译器的优化之后，会直接将 str 进行移动构造，把资源转移给 ValStr，大大提高了效率！！

那么，现在编写代码，就基本不需要考虑传值返回带来的性能上的负担。左值引用的缺陷得到了弥补！

当然了， 我们也可以手动优化，那就是 return move(str); 将 str 强行识别成为右值，这样子 return 的时候，就会调用移动构造。

---

不可以如下代码。下方其他不变，只是把返回值变成了 string&& 类型，也就是用右值返回。

这是错误的做法，不管是返回左值引用，还是右值引用，都不可以的，因为 str 是局部对象，出了作用域就销毁，所以不可以返回引用。

而是返回 string 类型，让它拷贝（当然了，如上优化成移动拷贝，把 str 的资源转移给接收的变量）。

simulate::string&& to_string(int value)
	{
		bool flag = true;
		if (value < 0)
		{
			flag = false;
			value = 0 - value;
		}

		simulate::string str;
		while (value > 0)
		{
			int x = value % 10;
			value /= 10;

			str += ('0' + x);
		}

		if (flag == false)
		{
			str += '-';
		}

		std::reverse(str.begin(), str.end());
		return str;
	}

---

此外，C++11 的 STL 的插入函数，也使用了移动版本。

如果自己实现（这里就不展示了，和 string 类似），可以观察到两者区别，如下。

小总结：

1. 左值引用减少拷贝，提高效率。
2. 右值引用也减少拷贝，提高效率。
3. 左值引用是对变量的直接引用，直接减少了拷贝。
4. 右值引用是间接减少拷贝，识别出如果是右值，那么直接使用移动拷贝，转移资源，减少拷贝。

完美转发

属性丢失

如下，是一个万能引用的例子（PerfectForward 函数），既可以引用左值，又可以引用右值。

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<typename T>
void PerfectForward(T&& t)
{
	Fun(t);
}

int main()
{
	PerfectForward(10);           // 右值

	int a;
	PerfectForward(a);            // 左值
	PerfectForward(std::move(a)); // 右值

	const int b = 8;
	PerfectForward(b);		      // const 左值
	PerfectForward(std::move(b)); // const 右值
}

但是，运行之后，发现 Func(t); 的结果和预期并不相同，这就是属性丢失的问题。

为什么会属性丢失

如下， 10 被 rr1 右值引用之后，既可以取地址，又可以 ++ 。这是因为， rr1 已经变成了左值，这是语法所规定的。如概念中最后一段所说，给右值取别名后，会导致右值被存储到特定位置。这就成为了左值。

这样做的原因如下，如果移动构造中， s 依然是右值，那么根据右值的性质，s 是无法被改变的；而 swap(s) 改变了 s 中的成员，这样的代码就无法通过编译！所以，根据需要， 右值引用之后的 s，必须是左值，才可以被修改！它右值的属性就丢失了！

解决方法

如果想要保持右值引用之后，其原生属性不变，就需要用到完美转发。如下，t 在函数内部，由于属性丢失的原因，是左值， forward(t) 让 t 保持了它原有的属性，如果传入的参数是左值，t 就是左值；传入的参数是右值，t 就是右值。

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<typename T>
void PerfectForward(T&& t)
{
	Fun(forward<T>(t));
}

模板的万能引用只是提供了能够接收同时接收左值引用和右值引用的能力，但是引用类型的唯一作用就是限制了接收的类型，后续使用中都退化成了左值，我们希望能够在传递过程中保持它的左值或者右值的属性, 就需要用完美转发。

📕 新的类功能

默认成员函数

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

1. 构造函数
2. 析构函数
3. 拷贝构造函数
4. 拷贝赋值重载
5. 取地址重载
6. const 取地址重载

最后重要的是前4个，后两个用处不大。默认成员函数就是我们不写编译器会生成一个默认的。C++11 新增了两个：移动构造函数和移动赋值运算符重载。

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

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

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

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

default 和 delete 关键字

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

如下，强制生成移动构造和移动复制，通过自己写的 string 类（在上方有代码），从控制台打印的内容 可以知道其调用逻辑。

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& operator=(const Person& p)
	{
		if(this != &p)
		{
			_name = p._name;
			_age = p._age;
		}
		return *this;
	}

	// 强制生成移动构造和移动赋值
	Person(Person&& p) = default;
	Person& operator=(Person&& p) = default;

	~Person()
	{
		cout << "~Person()" << endl;
	}

private:
	simulate::string _name; // 自定义类型
	int _age = 1;		   // 内置类型
};

int main()
{
	Person s1("张三", 18);
	Person s2 = s1;
	Person s3 = std::move(s1);  // 自定义类型，调用给自己的移动构造
	cout << endl << endl;
	Person s4;
	s4 = std::move(s2);  // 移动赋值，默认生成的调用自定义类型的移动赋值（由于 string 未实现，所以调用赋值重载）

	return 0;
}

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

如下，Person 类里面，编译器不会默认生成拷贝构造。

class Person {
public:
	Person(const char* name = "", int age = 0)
		:_name(name)
		, _age(age)
	{}
	Person(const Person& p) = delete;
private:
	simulate::string _name;
	int _age;
};

📕 lambda 表达式

问题的提出

在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;
}

如果待排序元素为自定义类型，需要用户定义排序时的比较规则，如下的 ComparePriceLess 和 ComparePriceGreater ：

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());
}

随着C++语法的发展，人们开始觉得上面的写法太复杂了，每次为了实现一个algorithm算法，都要重新去写一个类，如果每次比较的逻辑不一样，还要去实现多个类，特别是相同类的命名，这些都给编程者带来了极大的不便。因此，在C++11语法中出现了Lambda表达式。

概念

如下是使用 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;
	}); // 按照评价降序排序
}

---

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

lambda 表达式的捕捉列表描述了上下文中，哪些数据可以被lambda使用，以及使用的方式传值还是传引用。传值捕捉，就是将变量拷贝一份，lambda 的函数体内使用的是变量的拷贝；传引用捕捉，lambda 函数体内部使用的是变量的引用。例子如下：

int main()
{
	int x = 0, y = 1;
	int m = 0, n = 1;

	auto swap1 = [](int& rx, int& ry)
	{
		int tmp = rx;
		rx = ry;
		ry = tmp;
	};

	swap1(x, y);
	cout << x << " "<< y << endl;

	// 传值捕捉
	auto swap2 = [x, y]() mutable
	{
		int tmp = x;
		x = y;
		y = tmp;
	};

	swap2();
	cout << x << " " << y << endl;

	// 引用捕捉
	auto swap3 = [&x, &y]()
	{
		int tmp = x;
		x = y;
		y = tmp;
	};

	swap3();
	cout << x << " " << y << endl;

	// 混合捕捉
	auto func1 = [&x, y]()
	{
		//...
	};

	// 全部引用捕捉
	auto func2 = [&]()
	{
		//...
	};

	// 全部传值捕捉
	auto func3 = [=]()
	{
		//...
	};

	// 全部引用捕捉，x传值捕捉
	auto func4 = [&, x]()
	{
		//...
	};

	return 0;
}

如下，lambda 的参数列表，和函数参数类似，调用 lambda 的时候传参即可。

int main()
{
// 最简单的lambda表达式, 该lambda表达式没有任何意义
	[] {};
// 省略参数列表和返回值类型，返回值类型由编译器推导为int
	int a = 3, b = 4;
	[=] {return a + 3; };
// 省略了返回值类型，无返回值类型
	auto fun1 = [&](int c) {
		b = a + c;
	};
	fun1(10)
	cout<<a<<" "<<b<<endl;
// 各部分都很完善的lambda函数
	auto fun2 = [=, &b](int c)->int{return b += a+ c; };
	cout<<fun2(10)<<endl;
// 传值捕捉x
	int x = 10;
	auto add_x = [x](int a) mutable { x *= 2; return a + x; };
	cout << add_x(10) << endl;
	return 0;
}

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

函数对象和 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表达式，编译器会自动生成一个类，在该类中重载了operator()。

📕 可变参数模板

C++11的新特性可变参数模板能够让您创建可以接受可变参数的函数模板和类模板，相比C++98/03，类模版和函数模版中只能含固定数量的模版参数，可变模版参数无疑是一个巨大的改进。然而由于可变模版参数比较抽象，使用起来需要一定的技巧。

如下，是一个基本可变参数的函数模板：

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

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

函数递归方式展开参数包

// 递归终止函数
template <class T>
void ShowList(const T& t)
{
	cout << t << endl;
}
// 展开函数
template <class T, class ...Args>
void ShowList(T value, Args... args)
{
	cout << value <<" ";
	ShowList(args...);
}
int main()
{
	ShowList(1);
	ShowList(1, 'A');
	ShowList(1, 'A', std::string("sort"));
	return 0;
}

逗号表达式展开参数包

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

expand函数中的逗号表达式：(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数组的过程中就将参数包展开了，这个数组的目的纯粹是为了在数组构造的过程展开参数包。

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;
}

STL 中的 emplace 接口

由 可变参数模板，STL中新增了emplace函数接口。

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

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

如下，emplace_back支持可变参数，拿到构建pair对象的参数后自己去创建对象。那么在这里我们可以看到除了用法上，和push_back没什么太大的区别。

int main()
{
	std::list< std::pair<int, char> > mylist;
	mylist.emplace_back(10, 'a');
	mylist.emplace_back(20, 'b');
	mylist.emplace_back(make_pair(30, 'c'));
	mylist.push_back(make_pair(40, 'd'));
	mylist.push_back({ 50, 'e' });
	for (auto e : mylist)
		cout << e.first << ":" << e.second << endl;
	return 0;
}

下面试一下带有拷贝构造和移动构造的simulate::string 。其实差别也不到，emplace_back是直接构造了，push_back是先构造，再移动构造，其实也还好。

int main()
{
std::list< std::pair<int, simulate::string> > mylist;
mylist.emplace_back(10, "sort");
mylist.emplace_back(make_pair(20, "sort"));
mylist.push_back(make_pair(30, "sort"));
mylist.push_back({ 40, "sort"});
return 0;
}

📕 包装器

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

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

第一行的 func可能是什么呢？那么func可能是函数名？函数指针？函数对象(仿函数对象)？也有可能是lamber表达式对象？所以这些都是可调用的类型！如此丰富的类型，可能会导致模板的效率低下！

ret = func(x);

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;
}

通过上面的程序验证，我们会发现useF函数模板实例化了三份。

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

std::function 在头文件 < functional >
// 类模板原型如下
template function; // undefined
template <class Ret, class… Args>
class function<Ret(Args…)>;
模板参数说明：
Ret: 被调用函数的返回类型
Args…：被调用函数的形参

使用方法如下：

#include <functional>
int f(int a, int b)
{
	return a + b;
}

struct Functor {
public:
	int operator() (int a, int b)
	{
		return a + b;
	}
};

class Plus {
public:
	static int plusi(int a, int b)
	{
		return a + b;
	}
	double plusd(double a, double b)
	{
		return a + b;
	}
};

int main()
{
	// 函数名(函数指针)
	std::function<int(int, int)> func1 = f;
	cout << func1(1, 2) << endl;
	// 函数对象
	std::function<int(int, int)> func2 = Functor();
	cout << func2(1, 2) << endl;
	// lamber表达式
	std::function<int(int, int)> func3 = [](const int a, const int b) {
		return a + b;
	};
	cout << func3(1, 2) << endl;
	// 类的成员函数
	std::function<int(int, int)> func4 = &Plus::plusi;
	cout << func4(1, 2) << endl;
	std::function<double(Plus, double, double)> func5 = &Plus::plusd;
	cout << func5(Plus(), 1.1, 2.2) << endl;
	return 0;
}

有了包装器，就可以解决上面的模板的效率低下，实例化多份的问题。

#include <functional>
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()
{
	// 函数名
	std::function<double(double)> func1 = f;
	cout << useF(func1, 11.11) << endl;
	// 函数对象
	std::function<double(double)> func2 = Functor();
	cout << useF(func2, 11.11) << endl;
	// lamber表达式
	std::function<double(double)> func3 = [](double d)->double{ return d /4;};
	cout << useF(func3, 11.11) << endl;
	return 0;
}