C++11——新的类功能、可变参数模板

一、新的类功能

1.测试代码

下面的测试案例需用用到移动构造和移动赋值的测试代码，我们给出上篇博文封装过移动构造和移动赋值的简化版string类放到下面，以方便后续的测试代码中进行调用观察现象：

namespace cpp
{
	class string
	{
	public:
        // 构造函数
		string(const char* str = "")
			:_size(strlen(str))
			, _capacity(_size)
		{
			//cout << "string(char* str)" << endl;
			_str = new char[_capacity + 1];
			strcpy(_str, str);
		}
		// 交换两个对象的数据
		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& operator=(const string& s)
		{
			cout << "string& operator=(string s) -- 深拷贝" << endl;
			string tmp(s);
			swap(tmp);
			return *this;
		}
		// 移动构造
		string(string&& s)
			:_str(nullptr)
			, _size(0)
			, _capacity(0)
		{
			cout << "string(string&& s) -- 移动构造" << endl;
			swap(s);
		}
		// 移动赋值
		string& operator=(string&& s)
		{
			cout << "string& operator=(string&& s) -- 移动赋值" << endl;
			swap(s);
			return *this;
		}
        // 析构函数
		~string()
		{
			delete[] _str;
			_str = nullptr;
		}
	private:
		char* _str;
		size_t _size;
		size_t _capacity; // 不包含最后做标识的\0
	};
}

---

2.默认成员函数

原来C++类中（C++11之前），有6个默认成员函数：

• 1、构造函数

• 2、析构函数

• 3、拷贝构造函数

• 4、拷贝赋值重载

• 5、取地址重载

• 6、const 取地址重载

最重要的是前4个，后两个用处不大。默认成员函数就是我们不写编译器会生成一个默认的。C++11 新增了两个：移动构造函数和移动赋值运算符重载。针对移动构造和移动赋值，编译器也会默认生成，不过生成的条件极其苛刻，下面展开来讨论：

• 1、移动构造：

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

• 2、移动赋值：

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

• 3、总结：

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

• 4、示例：

• 对于如下的Person类，我们不需要写析构、拷贝构造、赋值重载，因为Person的成员变量_ name是自定义类型，会自动去调用string类的拷贝构造、析构、赋值重载完成深拷贝。而内置类型_ age完成值拷贝即可。

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:
	cpp::string _name;
	int _age;
};
int main()
{
	Person s1;
	Person s2 = s1;//拷贝构造
	Person s3 = std::move(s1);//移动构造
	Person s4;
	s4 = std::move(s2);//移动赋值
	return 0;
}

• 由于VS2013没有完全支持C++11，因此上述代码无法在VS2013当中验证，需要使用更新一点的编译器进行验证，比如VS2019。

因为我们都没写拷贝构造、析构、赋值，所以编译器会默认生成移动构造和移动赋值运算符重载。针对main函数的测试用例，很明显，s2 = s1是拷贝构造，下面的两个分别调用移动构造和移动赋值：

但凡我把Person类中的任何一个拷贝构造或析构或赋值放出来，结果都是去调用string类的拷贝构造函数去完成深拷贝：

---

3.类成员变量初始化

默认生成的构造函数，对于自定义类型会自动调用它的构造函数进行初始化，对于内置类型并不会进行处理，于是C++11允许在类定义时给成员变量初始缺省值，默认生成构造函数会使用这些缺省值初始化，这个我们在类和对象默认就讲了，这里再简要提下。

class Person
{
public:
	//……
private:
	//C++11允许非静态成员变量在声明时进行初始化赋值
	string _name = "张三";
	int _age = 20;
	static int _num;//静态成员变量不能给缺省值
};

---

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

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

为了让编译器生成移动构造和移动赋值，我们可以使用default关键字显示指定生成移动构造或移动赋值：

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&& pp) = default;
	//强制生成移动赋值
	Person& operator=(Person&& pp) = default;
private:
	cpp::string _name;
	int _age;
};
int main()
{
	Person s1;
	Person s2 = s1; // 移动构造
	Person s3 = std::move(s1); // 移动构造
	Person s4;
	s4 = std::move(s2); // 移动构造
	return 0;
}

---

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

在C++中，如果想禁止生成默认成员函数，我们有如下两种方式：

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

示例：我不想让一个类被拷贝，那么在拷贝构造声明的后面加上=delete即可：

---

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

• 这个我们在继承和多态章节已经进行了详细讲解，这里再强调下：

• 1、final：修饰虚函数，表示该虚函数不能再被重写，修饰类表示不能被继承。

这里我父类的虚函数Drive不想被其它人重写，在其后面加上final即可，此时子类就无法对Drive进行重写了，如下：

final修饰一个类，让其不能被继承，如下：

• 2、override: 检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错。

二、可变参数模板

1.可变参数模板的概念

• C++11的新特性可变参数模板能够让您创建可以接受可变参数的函数模板和类模板，相比C++98/03，类模版和函数模版中只能含固定数量的模版参数，可变模版参数无疑是一个巨大的改进。然而由于可变模版参数比较抽象，使用起来需要一定的技巧，所以这块还是比较晦涩的。现阶段呢，我们掌握一些基础的可变参数模板特性就够我们用了，所以这里我们点到为止。

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

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

• 上面的参数args前面有省略号，所以它就是一个可变模版参数，我们把带省略号的参数称为“参数包”，它里面包含了0到N（N>=0）个模版参数。
• 模板参数包Args和函数形参参数包args的名称可以自己进指定。

现在调用ShowList函数就可以传入任意个数的任意类型的参数了：

int main()
{
	ShowList(1);
	ShowList(1, 1.1);
	ShowList(1, 1.1, string("######"));
	// ShowList();
	return 0;
}

我们也可以通过sizeof获得参数包的个数，但注意格式：sizeof…(args)

template <class ...Args>
void ShowList(Args... args)
{
	cout << sizeof...(args) << endl;//获取参数包中参数的个数
}

我们无法直接获取参数包args中的每个参数的，只能通过展开参数包的方式来获取参数包中的每个参数，这是使用可变模版参数的一个主要特点，也是最大的难点，即如何展开可变模版参数。语法并不支持使用args[i]这样方式获取可变参数。也不支持auto范围for的方式获取可变参数：

template <class ...Args>
void ShowList(Args... args)
{
	/*不支持args[i]
	for (size_t i = 0; i < sizeof...(args); ++i)
	{
		cout << args[i] << endl;
	}*/
	/*不支持auto范围for
	for (auto& e : args)
	{
		cout << e << endl;
	}*/
}

由于语法不支持使用args[i]这样方式获取可变参数，所以我们的用一些奇招来一一获取参数包的值。

---

2.参数包的展开方式

2.1.递归函数方式展开参数包

递归展开参数包需要实现两个函数，且二者同名：

• 一、递归函数
• 二、递归终止函数

我们分开来讨论：

一、递归函数：

1. 给可变参数的函数模板增加一个模板参数，用于后续获得每一个参数的值
2. 在该函数模板中递归调用函数模板，把剩下的参数包传进去
3. 一直递归下去，每次分离参数包中的一个参数，直至全部分离出来

示例：

//递归函数
template <class T, class ...Args>
void ShowList(const T& val, Args... args)
{
	cout << sizeof...(args) << endl;//获取参数包中参数的个数
	cout << val << "->" << typeid(val).name() << endl;
	ShowList(args...);
}

写好了递归函数，接下来完成终止函数，

二、递归终止函数：

这里我们也给出两个终止函数的方式：

1. 带参的终止函数
2. 无参的终止函数

先看带参的终止函数，结合递归函数和测试用例一起看：

//带参的终止函数
template <class T>
void ShowList(const T& val)
{
	cout << val << "->" << typeid(val).name() << " end" << endl;
}

根据参数的最匹配原则，当参数包只有一个参数的时候，编译器会优先匹配到此终止函数完成递归终止。接下来把整体的代码加上测试用例一起看：

//带参的终止函数
template <class T>
void ShowList(const T& val)
{
	cout << val << "->" << typeid(val).name() << " end" << endl;
}
//递归函数
template <class T, class ...Args>
void ShowList(const T& val, Args... args)
{
	cout << sizeof...(args) << endl;//获取参数包中参数的个数
	cout << val << "->" << typeid(val).name() << endl;
	ShowList(args...);
}
int main()
{
	ShowList(1, 'x', 1.1);
	return 0;
}

• 首先，1传给val，把x和1.1传给参数包，推出T的类型为int，参数包的个数为2，打印后，继续递归把x传给val，把1.1传给参数包，推出T的类型为char，参数表的个数为1，打印后再继续递归，此时参数包的个数只有一个，根据模板的最匹配原则，这一个参数会匹配到递归终止函数，
• 但该方法有一个弊端就是，我们在调用ShowList函数时必须至少传入一个参数，否则就会报错。因为此时无论是调用递归终止函数还是展开函数，都需要至少传入一个参数。

下面来看看无参的递归终止函数：

//无参的终止函数
void ShowList()
{}

此时当参数包的个数为0个的时候，就会走此函数，完成递归终止。

• 如果外部调用ShowList函数时就没有传入参数，那么就会直接匹配到无参的递归终止函数。
• 而我们本意是想让外部调用ShowList函数时匹配的都是函数模板，并不是让外部调用时直接匹配到这个递归终止函数。

结合测试用例一起看：

//无参的终止函数
void ShowList()
{}
//递归函数
template <class T, class ...Args>
void ShowList(const T& val, Args... args)
{
	cout << sizeof...(args) << endl;//获取参数包中参数的个数
	cout << val << "->" << typeid(val).name() << endl;
	ShowList(args...);
}
int main()
{
	ShowList(1, 'x', 1.1);
	cout << endl;
	ShowList(1, 2, 3, 4, 5);
	cout << endl;
	ShowList();
	return 0;
}

注意：递归终止的方式不能按照如下的方式写：

//递归函数
template <class T, class ...Args>
void ShowList(const T& val, Args... args)
{
	//错误的写法：
	if (sizeof...(args) == 0)
	{
		return;
	}
	cout << val << "->" << typeid(val).name() << endl;
	ShowList(args...);
}

• 函数模板并不能调用，函数模板需要在编译时根据传入的实参类型进行推演，生成对应的函数，这个生成的函数才能够被调用。
• 而这个推演过程是在编译时进行的，当推演到参数包args中参数个数为0时，还需要将当前函数推演完毕，这时就会继续推演传入0个参数时的ShowList函数，此时就会产生报错，因为ShowList函数要求至少传入一个参数。
• 这里编写的if判断是在代码编译结束后，运行代码时才会所走的逻辑，也就是运行时逻辑，而函数模板的推演是一个编译时逻辑。

---

2.2.逗号表达式展开参数包

这里我们先给出使用逗号表达式展开参数包的一个例子：

template <class T>
void PrintArg(const T& t)
{
	cout << t << " ";
}
template <class ...Args>
void ShowList(Args... args)
{
	//列表初始化+逗号表达式
	int arr[] = { (PrintArg(args), 0)... };
	cout << endl;
}
int main()
{
	ShowList(1, 'x', 1.1, string("hello world"));
	ShowList(1, 2, 3, 4, 5);
	return 0;
}

下面我将给出其演化的过程：

前面我们学习到了可以使用{ }列表初始化来初始化数组等内置类型和自定义类型，那么我可不可以直接把参数包放到列表初始化呢？

template <class ...Args>
void ShowList(Args... args)
{
	//列表初始化
	int arr[] = { args... };
	cout << endl;
}

这里很明显是不可以的，C++只允许数组里面是同一种类型，但是模板的可变参数就意味着我参数包的类型并不统一，会出现一会是int，一会是char……。为了解决此问题，我们可以单独封装一层函数（PrintArg），此函数专门用于获得参数包的每个数据并输出，但是这又会出现一个问题，我得不到一个返回值放回数组里头，为了解决返回值的问题，又使用了逗号表达式来解决：

• 逗号表达式会从左到右依次计算各个表达式，并且将最后一个表达式的值作为返回值进行返回。
• 将逗号表达式的最后一个表达式设置为一个整型值，确保逗号表达式返回的是一个整型值。
• 将处理参数包中参数的动作封装成一个函数，将该函数的调用作为逗号表达式的第一个表达式。

这里我们把逗号表达式的最后一个值设为0，此时我参数包里有几个参数，那么就有几个0，也就代表有几个值。调整后的代码如下：

template <class T>
void PrintArg(const T& t)
{
	cout << t << " ";
}
template <class ...Args>
void ShowList(Args... args)
{
	//列表初始化+逗号表达式
	int arr[] = { (PrintArg(args), 0)... };
	cout << endl;
}

注意：

• 可变参数的省略号需要加在逗号表达式外面，表示需要将逗号表达式展开，如果将省略号加在args的后面，那么参数包将会被展开后全部传入PrintArg函数，代码中的{(PrintArg(args), 0)…}将会展开成{(PrintArg(arg1), 0), (PrintArg(arg2), 0), (PrintArg(arg3), 0), etc…}。

此时我们就会发现，就和一开始我们给出的代码一致了，这就是是用来逗号表达式的方式展开参数包。下面给出测试用例：

int main()
{
	ShowList(1);
	ShowList(1, 1.1);
	ShowList(1, 1.1, string("######"));
}

当然，这里其实不用逗号表达式也可以，直接给PrintArg函数带上返回值即可完成逗号表达式的功能：

template <class T>
int PrintArg(const T& t)
{
	cout << t << " ";
	return 0;
}
template <class ...Args>
void ShowList(Args... args)
{
	//列表初始化
	int arr[] = { PrintArg(args)... };
	cout << endl;
}

此时可以传入多种类型的参数了，但是不能不传参数，因为数组的大小不能为0，为了支持不传参数，我们需要单独写个无参的ShowList函数，就像无参版的终止函数那样：

//支持无参调用
void ShowList()
{
	cout << endl;
}
template <class T>
int PrintArg(const T& t)
{
	cout << t << " ";
	return 0;
}
template <class ...Args>
void ShowList(Args... args)
{
	//列表初始化
	int arr[] = { PrintArg(args)... };
	cout << endl;
}

总结：

• 这种展开参数包的方式，不需要通过递归终止函数，是直接在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数组的过程中就将参数包展开了，这个数组的目的纯粹是为了在数组构造的过程展开参数包。

---

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

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

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

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

emplace系列接口的优势到底在哪里呢？

int main()
{
	std::list< std::pair<int, char> > mylist;
	// emplace_back支持可变参数，拿到构建pair对象的参数后自己去创建对象
	// 那么在这里我们可以看到除了用法上，和push_back没什么太大的区别
	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;
}

int main()
{
	// 下面我们试一下带有拷贝构造和移动构造的bit::string，再试试呢
	// 我们会发现其实差别也不到，emplace_back是直接构造了，push_back
	// 是先构造，再移动构造，其实也还好。
	std::list< std::pair<int, cpp::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;
}

总结：

• emplace系列接口最大的特点就是支持传入参数包，用这些参数包直接构造出对象，这样就能减少一次拷贝，这就是为什么有人说emplace系列接口更高效的原因。
• 但emplace系列接口并不是在所有场景下都比原有的插入接口高效，如果传入的是左值对象或右值对象，那么emplace系列接口的效率其实和原有的插入接口的效率是一样的。
• emplace系列接口真正高效的情况是传入参数包的时候，直接通过参数包构造出对象，避免了中途的一次拷贝。

---

其实这里对可变参数模版讲解的还不够深刻，具体可以看看大佬龙哥（2021dragon）的博文，个人觉得他总结的确实全面，且通俗易懂，下面附上链接：2021dragon -> 可变参数模板