【c++11】新的类功能和可变参数包_参数包上下文展开

新增默认成员函数

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

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

默认成员函数就是我们不写编译器会生成一个默认的。

c++11后又新增两个

1. 移动构造函数
2. 移动运算符重载

对于新增的这两个，但其默认生成的条件比较苛刻：

如果你没有自己实现移动构造函数，且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一个。那么编译器会自动生成一个默认移动构造。

为什么移动构造函数生成的条件那么严苛呢？
因为对于一个类，如果实现了析构，拷贝构造等函数，说明了这个类需要进行深拷贝，最好是自己对这个类的资源进行控制和转移，编译器希望我们自己实现移动构造函数。

默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动构造，如果实现了就调用移动构造，没有实现就调用拷贝构造。

看如下代码：

class Person
{
public:
	Person(const char* name, int age)
		:_name(name)
		, _age(age)
	{}
	
			/*~Person()
				{}*/
private:
	lx::string _name;
	int _age;
};

int main()
{
	Person s1("张三",18);
	Person s2 = s1;
	Person s3 = move(s1);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

可以看到，编译器默认生成的移动函数调用了lx::string 的移动构造函数，所以最后会打印出一个拷贝构造和一个移动构造。

当我们实现一个拷贝构造函数

	Person(const Person& p):_name(p._name)
		,_age(p._age)
		{}
	
1
2
3
4
5

那么编译器不会生成移动构造函数，那么会直接调用拷贝构造函数。

移动赋值重载函数也类似：

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

类成员变量初始化

C++11允许在类定义时给成员变量初始缺省值。

class grades {
private:
	int Math=100;
	int Chinese=100;
	int English=100;
};
1
2
3
4
5
6

关键字

default

强制生成默认函数的关键字default。假设你需要使用某个默认的函数，在某些情况下该函数没有默认生成，比如：我们提供了拷贝构造，就不会生成移动构造了，那么我们可以使用default关键字显示指定移动构造生成。

Person(Person&& p) = default;
1

delete

禁止生成默认函数的关键字delete。
如果能想要限制某些默认函数的生成，在C++98中，是该函数设置成private，并且只声明函数，这样只要其他人想要调用就会报错。

在C++11中更简单，只需在该函数声明加上=delete即可，该语法指示编译器不生成对应函数的默认版本，称=delete修饰的函数为删除函数。

Person(const Person& p) = delete;
1

如果再次运行，就会得到这样的报错

尝试引用已经删除的函数。

委托构造

委托构造，也是一个构造函数，但它不直接对类对象进行赋值，而是委托其它构造函数对类对象进行处理。如：

class Person
{
public:
	Person(const char* name, int age)
		:_name(name)
		, _age(age)
	{}
	//委托构造
	Person(const char* name)
		:Person(name, 18)
	{}
	private:
	lx::string _name;
	int _age;
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

注意：委托构造函数也要于其它构造函数进行区分，否则编译器无法识别。

了解即可，可以不深入了解其运用。等用到的时候在仔细研究一下就行了。

可变参数包

C++11的新特性可变参数模板能够创建可以接受可变数量参数的函数模板和类模板，相比C++98/03，类模版和函数模版中只能含固定数量的模版参数，可变模版参数无疑是一个巨大的改进。

//Args是模板的可变参数包
template <class ...Args>
//args是函数的可变参数包
// 声明一个参数包Args...args，这个参数包中可以包含0到任意个模板参数。
void fun(Args ...args)
{
	cout << sizeof...(args) << endl;
}
1
2
3
4
5
6
7
8

上面的参数args前面有省略号，所以它就是一个可变模版参数，我们把带省略号的参数称为“参数包”，它里面包含了0到N（N>=0）个模版参数。

我们无法直接获取参数包args中的每个参数的，只能通过展开参数包的方式来获取参数包中的每个参数。
那么如何获取参数包的每个参数呢？
是这样嘛

template <class ...Args>
void fun(Args ...args)
{
	for(int i=0;i<sizeof...(args);i++)
	{
	cout<<args[i]<<endl;
	}
}
1
2
3
4
5
6
7
8

是不是觉得就是这样的啊，但是

编译器提示要在上下文扩展参数包，不能用打印数组的方式解析参数包。

递归展开参数包

代码如下：

//终止函数
void fun()
{
	cout << endl;
}

template <class T,class ...Args>
void fun(const T& val,Args ...args)
{
	cout << val << ':';
	cout << sizeof...(args) << endl;//  打印出可变参数包的大小
	fun(args...);
}

int main()
{
  	fun(1,‘a’,std::string("hello wrold"));

	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

结果如下

成功解析出了可变参数包的内容。
那么是如何解析出来的呢？
且听我细细分说：

运用了函数递归的原理

每次递归的时候将参数包的第一个传递给val，后面的参数形成一个新的参数包，每一次递归，参数包就减少一位i，被打印在屏幕上。

当参数包里的参数为0时，也就不能为下一次递归传递参数，所以编译器会调用
终止函数。调用完了后也会依次回溯。

逗号表达式展开参数包

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

template<class T>
void print_arg(const T& t)
{
	cout << t << " ";
}

template <class ...Args>
void  fun(Args... args)
{
	int arr[] = { (print_arg(args),0)... };
	cout << endl;
}

int main()
{
  	fun(1,‘a’,std::string("hello wrold"));

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

也能打印出参数包里的每一个参数。
同样，这是怎么来的呢？
且听我一一道来：
逗号表达式：(printarg(args), 0)，先执行printarg(args)，再得到逗号表达式的结果0。
同时还用到了C++11的另外一个特性——初始化列表，通过初始化列表来初始化一个变长数组， {(prin_targ(args), 0)…}将会展开成

((print_arg(arg1),0), (print_arg(arg2),0), (print_arg(arg3),0), etc... )
1

对于我们的函数，在编译阶段，编译器会将其推演生成成这样一段代码，

void fun(int a1, char a2, std::string a3)
{
	int arr[] = { (print_arg(a1),0),(print_arg(a2),0),(print_arg(a3),0) };
	cout << endl;
}
1
2
3
4
5

最终会创建一个元素值都为0的数组int arr[sizeof…（Args）]。

由于可变模版参数比较抽象，使用起来需要一定的技巧，所以这块还是比较晦涩的。现阶段呢，我们掌握一些基础的可变参数模板特性就够我们用了，所以这里我们点到为止，以后大家如果有需要，再可以深入学习。

结语

本次的博客就到这了。

我是Tom-猫，
如果觉得有帮助的话，记得
一键三连哦ヾ(≧▽≦*)o。

咱们下期再见。