55 C++11新特性 · 中

        • 可以使用【sizeof...】运算符去计算参数包中参数的个数。

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<string>
using namespace std;


template <class ...Args>
void Print(Args&&... args)
{
	cout << sizeof...(args) << endl;
}
int main()
{
	double x = 2.2;
	Print(); // 包里有0个参数
	Print(1); // 包里有1个参数
	Print(1, string("xxxxx")); // 包里有2个参数
	Print(1.1, string("xxxxx"), x); // 包里有3个参数
	return 0;
}

// 原理1：编译本质这里会结合引用折叠规则实例化出以下四个函数
void Print();
void Print(int&& arg1);
void Print(int&& arg1, string&& arg2);
void Print(double&& arg1, string&& arg2, double& arg3);

// 原理2：更本质去看没有可变参数模板，我们实现出这样的多个函数模板才能支持
// 这里的功能，有了可变参数模板，我们进一步被解放，他是类型泛化基础
// 上叠加数量变化，让我们泛型编程更灵活。
// 上面的一个可变参数模板等价于实现了下面四个模板
void Print();

template <class T1>
void Print(T1&& arg1);

template <class T1, class T2>
void Print(T1&& arg1, T2&& arg2);

template <class T1, class T2, class T3>
void Print(T1&& arg1, T2&& arg2, T3&& arg3);
// ...

        【函数模板】与【可变参数函数模板】作用类比：

                ① 函数模板：本来要写多个函数，现在写一个函数模板即可；

                ② 可变参数函数模板：本来要写多个函数模板，现在写一个可变参数模板即可。

        可变参数函数模板原理还是通过编译器进行推理可变参数的类型。

（二）包扩展

        • 对于一个参数包，我们除了能计算他的参数个数，我们能做的唯一的事情就是扩展它，当扩展一个包时，我们还要提供用于每个扩展元素的模式，扩展一个包就是将它分解为构成的元素，对每个元素应用模式，获得扩展后的列表（通俗来讲，就是对这些可变数量的参数进行展开和处理的一种机制）。我们通过在模式的右边放一个省略号(...)来触发扩展操作。底层的实现细节如下图所示。

        • C++还支持更复杂的包扩展，直接将参数包依次展开依次作为实参给一个函数去处理。

        示例代码如下：

不支持以数组的形式进行访问：

template <class ...Args>
void Print(Args... args)
{
	 // 可变参数模板编译时解析
	 // 下面是运行获取和解析，所以不支持这样用
	 cout << sizeof...(args) << endl;
	 for (size_t i = 0; i < sizeof...(args); i++)
	 {
		 cout << args[i] << " ";
	 }
	 cout << endl;
}
int main()
{
	Print();
	Print(1);
	Print(1, string("xxxxx"));
	Print(1, string("xxxxx"), 2.2);
	return 0;
}

使用递归的方式进行可变参数的访问：

void ShowList()
{
	// 编译器时递归的终止条件，参数包是0个时，直接匹配这个函数
	cout << endl;
}
template <class T, class ...Args>
void ShowList(T x, Args... args)
{
	cout << x << " ";
	// args是N个参数的参数包
	// 调用ShowList，参数包的第一个传给x，剩下N-1传给第二个参数包
	ShowList(args...);
}
// 编译时递归推导解析参数
template <class ...Args>
void Print(Args... args)
{
	ShowList(args...);
}
int main()
{
	Print();
	Print(1);
	Print(1, string("xxxxx"));
	Print(1, string("xxxxx"), 2.2);
	return 0;
}

ShowList参数解析：

template <class T, class ...Args>
void ShowList(T x, Args... args)
{
	cout << x << " ";
	Print(args...);
}
 //Print(1, string("xxxxx"), 2.2);调用时
 //本质编译器将可变参数模板通过模式的包扩展，编译器推导的以下三个重载函数函数
void ShowList(double x)
{
	cout << x << " ";
	ShowList();
}

void ShowList(string x, double z)
{
	cout << x << " ";
	ShowList(z);
}

void ShowList(int x, string y, double z)
{
	cout << x << " ";
	ShowList(y, z);
}
void Print(int x, string y, double z)
{
	ShowList(x, y, z);
}

其他场景下的理解：

template <class T>
const T& GetArg(const T& x)
{
	cout << x << " ";
	return x;
}

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

template <class ...Args>
void Print(Args... args)
{
	// 注意GetArg必须返回或者到的对象，这样才能组成参数包给Arguments
	Arguments(GetArg(args)...);
}
// 本质可以理解为编译器编译时，包的扩展模式
// 将上面的函数模板扩展实例化为下面的函数
void Print(int x, string y, double z)
{
	Arguments(GetArg(x), GetArg(y), GetArg(z));
}

int main()
{
	Print(1, string("xxxxx"), 2.2);
	return 0;
}

        实践当中不太会对可变模版参数进行处理，但要知道有可以取每个参数的操作，实践当中要取可变参数是可以直接匹配：empalce系列接口。

（三）emplace系列接口

        接口的声明如下：

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

template <class... Args> 
iterator emplace (const_iterator position, Args&&... args);

        • C++11以后STL容器新增了empalce系列的接口，empalce系列的接口均为模板可变参数，功能上兼容push和insert系列，但是empalce还支持新玩法，假设容器为container<T>，empalce还支持直接插入构造T对象的参数，这样有些场景会更高效一些，可以直接在容器空间上构造T对象。

程序一：

#include<list>
#include"string.h"
// emplace_back总体而言是更高效，推荐以后使用emplace系列替代insert和push系列
int main()
{
	list<zyb::string> lt;//对象参数为单参数时的场景
	zyb::string s1("111111111111");

	// 传左值，跟push_back一样，走拷贝构造
	lt.emplace_back(s1);
	cout << "*********************************" << endl;

	// 右值，跟push_back一样，走移动构造
	lt.emplace_back(move(s1));
	cout << "*********************************" << endl;

	// 直接把构造string参数包往下传，直接用string参数包构造string
	// 这里达到的效果是push_back做不到的
	lt.emplace_back("111111111111");
	cout << "*********************************" << endl;


	list<pair<zyb::string, int>> lt1;//对象参数为多参数时的场景
    pair<zyb::string, int> kv("苹果", 1);
	// 跟push_back一样
	// 构造pair + 拷贝/移动构造pair到list的节点中data上
	
	lt1.emplace_back(kv);
	cout << "*********************************" << endl;
	// 跟push_back一样
	lt1.emplace_back(move(kv));
	cout << "*********************************" << endl;

	// 直接把构造pair参数包往下传，直接用pair参数包构造pair
	// 这⾥达到的效果是push_back做不到的
	lt1.emplace_back("苹果", 1);
	cout << "*********************************" << endl;
	return 0;
}

        以string为例，传左值和右值的push_back和emplace_back没区别；不一样的地方在直接把构造string的参数包往下传，则会直接用string参数包构造string。push_back则是构造 + 移动构造 + 析构；两者的效率差距不大，因为移动构造的代价小。

        为什么会这样呢：因为push_back为普通函数，类型已知为string，在例子中使用的是右值参数那个万能引用构造，而单参数支持隐式类型转换，也就是先会构造一个临时对象，右值引用的是这个临时对象，再使用移动构造把临时对象的资源给节点对象，最后析构掉这个临时对象。而emplace_back 是一个可变参数模板，类型还未确定，在这里例子中传过来参数后，emplace_back函数通过参数推导后会实例化为const char* 类型的函数，此时不存在构造，然后直接构造一个string给节点的data。

        当传入的是多参数的pair，直接传参数的话push_back要写成：push_back（{苹果，1}），而emplace_back（{苹果，1}）这样写则是错误的，因为emplace_back需要一个明确的类型，而这个{}不具有具体类型，只能是如下写法：emplace_back（苹果，1）。

        emplace_back的浅拷贝和深拷贝的效率都会提高，特别是浅拷贝，深拷贝的效率提升不够明显。

        • emplace_back总体而言是更高效，推荐以后使用emplace系列替代insert和push系列。

        • 第二个程序中我们模拟实现了list的emplace和emplace_back接口，这里把参数包不断往下传递，最终在结点的构造中直接去匹配容器存储的数据类型T的构造，所以达到了前面说的empalce支持直接插入构造T对象的参数，这样有些场景会更高效一些，可以直接在容器空间上构造T对象。

程序二：

// List.h
namespace zyb
{
	template<class T>
	struct ListNode
	{
		ListNode<T>* _next;
		ListNode<T>* _prev;
		T _data;
		ListNode(T&& data)
			:_next(nullptr)
			, _prev(nullptr)
			, _data(move(data))
		{}
		template <class... Args>
		ListNode(Args&&... args)
			: _next(nullptr)
			, _prev(nullptr)
			, _data(std::forward<Args>(args)...)
		{}
	};
	template<class T, class Ref, class Ptr>
	struct ListIterator
	{
		typedef ListNode<T> Node;
		typedef ListIterator<T, Ref, Ptr> Self;
		Node* _node;
		ListIterator(Node* node)
			:_node(node)
		{}
		// ++it;
		Self& operator++()
		{
			_node = _node->_next;
			return *this;
		}
		Self& operator--()
		{
			_node = _node->_prev;
			return *this;
		}
		Ref operator*()
		{
			return _node->_data;
		}
		bool operator!=(const Self& it)
		{
			return _node != it._node;
		}
	};
	template<class T>
	class list
	{
		typedef ListNode<T> Node;
	public:
		typedef ListIterator<T, T&, T*> iterator;
		typedef ListIterator<T, const T&, const T*> const_iterator;
		iterator begin()
		{
			return iterator(_head->_next);
		}
		iterator end()
		{
			return iterator(_head);
		}
		void empty_init()
		{
			_head = new Node();
			_head->_next = _head;
			_head->_prev = _head;
		}
		list()
		{
			empty_init();
		}
		void push_back(const T& x)
		{
			insert(end(), x);
		}
		void push_back(T&& x)
		{
			insert(end(), move(x));
		}
		iterator insert(iterator pos, const T& x)
		{
			Node* cur = pos._node;
			Node* newnode = new Node(x);
			Node* prev = cur->_prev;
			// prev newnode cur
			prev->_next = newnode;
			newnode->_prev = prev;
			newnode->_next = cur;
			cur->_prev = newnode;
			return iterator(newnode);
		}
		iterator insert(iterator pos, T&& x)
		{
			Node* cur = pos._node;
			Node* newnode = new Node(move(x));
			Node* prev = cur->_prev;
			// prev newnode cur
			prev->_next = newnode;
			newnode->_prev = prev;
			newnode->_next = cur;
			cur->_prev = newnode;
			return iterator(newnode);
		}
		template <class... Args>
		void emplace_back(Args&&... args)
		{
			insert(end(), std::forward<Args>(args)...);
		}
		// 原理：本质编译器根据可变参数模板生成对应参数的函数
		/*void emplace_back(string& s)
		{
			insert(end(), std::forward<string>(s));
		}
		void emplace_back(string&& s)
		{
			insert(end(), std::forward<string>(s));
		}
		void emplace_back(const char* s)
		{
			insert(end(), std::forward<const char*>(s));
		}
		*/
		template <class... Args>
		iterator insert(iterator pos, Args&&... args)
		{
			Node* cur = pos._node;
			Node* newnode = new Node(std::forward<Args>(args)...);
			Node* prev = cur->_prev;
			// prev newnode cur
			prev->_next = newnode;
			newnode->_prev = prev;
			newnode->_next = cur;
			cur->_prev = newnode;
			return iterator(newnode);
		}
	private:
		Node* _head;
	};
}

// Test.cpp
#include"List.h"
#include"string.h"
// emplace_back总体而言是更高效，推荐以后使用emplace系列替代insert和push系列
int main()
{
	zyb::list<zyb::string> lt;
	// 传左值，跟push_back一样，走拷贝构造
	zyb::string s1("111111111111");
	lt.emplace_back(s1);
	cout << "*********************************" << endl;
	// 右值，跟push_back一样，走移动构造
	lt.emplace_back(move(s1));
	cout << "*********************************" << endl;
	// 直接把构造string参数包往下传，直接用string参数包构造string
	// 这⾥达到的效果是push_back做不到的
	lt.emplace_back("111111111111");
	cout << "*********************************" << endl;
	zyb::list<pair<zyb::string, int>> lt1;
	// 跟push_back一样
	// 构造pair + 拷贝/移动构造pair到list的节点中data上
	pair<zyb::string, int> kv("苹果", 1);
	lt1.emplace_back(kv);
	cout << "*********************************" << endl;
	// 跟push_back一样
	lt1.emplace_back(move(kv));
	cout << "*********************************" << endl;
	
	// 直接把构造pair参数包往下传，直接用pair参数包构造pair
	// 这⾥达到的效果是push_back做不到的
	lt1.emplace_back("苹果", 1);
	cout << "*********************************" << endl;
	return 0;
}

        emplace_back在编译器编译时推测出可变参数的类型后，就会一直向下传，直接给到节点的构造，以单参数传递字符串字面量为例，过程如下图所示：

        注意传递参数包过程中，如果是 Args&&... args 的参数包，要用完美转发参数包，方式如下：

std::forward<Args>(args)...

        否则编译时包扩展后右值引用变量表达式就变成了左值。

三、新的类功能

(一)默认的移动构造和移动赋值

        • 原来C++类中，有6个默认成员函数：构造函数 / 析构函数 / 拷贝构造函数 / 拷贝赋值重载 / 取地址重载 / const 取地址重载，最后重要的是前4个，后两个用处不大，默认成员函数就是我们不写编译器会生成一个默认的。C++11 新增了两个默认成员函数，移动构造函数和移动赋值运算符重载。

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

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

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

        如下代码所示：

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()
{}*/
private:
	zyb::string _name;
	int _age;
};
int main()
{
	Person s1;
	Person s2 = s1;
	Person s3 = std::move(s1);
	Person s4;
	s4 = std::move(s2);
	return 0;
}

（二）成员函数声明时给缺省值

        成员变量声明时给缺省值是给初始化列表用的，如果没有显示在初始化列表初始化，就会在初始化列表用这个缺省值初始化，这个在类和对象部分已经写过博客了，更详细的可以取查看。

（三）defult 和 delete

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

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

        如下代码所示：

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;
	//Person(const Person& p) = delete;
private:
	zyb::string _name;
	int _age;
};
int main()
{
	Person s1;
	Person s2 = s1;
	Person s3 = std::move(s1);
	return 0;
}

（四）final 与 override

        这个在继承和多态章节的博客已经进行了详细讲过了，可以去该博客进行查阅。

四、STL中的一些变化

        • 下图圈起来的就是STL中的新容器，但是实际最有用的是unordered_map和unordered_set。这两个前面已经进行了非常详细的讲解，其他的了解一下即可。

        • STL中容器的新接口也不少，最重要的就是右值引用和移动语义相关的push/insert/emplace系列接口和移动构造与移动赋值，还有initializer_list版本的构造等，这些前面都讲过了，还有一些无关痛痒的如cbegin/cend等需要时查查文档即可。

        • 容器的范围for遍历，这个在容器部分也讲过了。

        以上内容仅供分享，若有错误，请多指正。