【C++11】晦涩难懂语法系列：可变参数模板

目录

可变参数模板

1.1 概念

1.2 可变参数模板定义

1.3 参数包的展开方式

1.3.1 递归展开参数包

1.3.2 逗号表达式展开参数包

1.4 STL的emplace系列函数

---

可变参数模板

1.1 概念

在C语言阶段，我们已经接触过可变参数，比如scand、printf等等

 

 

这里的 ... 就是可变参数列表，这也是 scanf 和 printf 可以接受多个参数的原因：使用了可变参数列表，但是scanf 和 printf 的可变参数是函数参数的可变参数，并不是模板的可变参数

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

下面只讲解可变参数模板

1.2 可变参数模板定义

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

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

• 上面的参数 args 前面有省略号，所以它就是一个可变模版参数，我们把带省略号的参数称为 “参数包”，它里面包含了0到N（N>=0）个模版参数。Args是一个模板参数包，args是一个函数形参参数包
• 我们无法直接获取参数包 args 中的每个参数的，只能通过展开参数包的方式来获取参数包中的每个参数，这是使用可变模版参数的一个主要特点，也是最大的难点，即如何展开可变模版参数。

可以在函数模板中通过 sizeof 计算参数包中参数的个数，代码如下

注意：sizeof 后面也需要加上参数列表 ... ，不加直接报错 

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

int main()
{
	ShowList(1);
	ShowList(1, 2);
	ShowList(11, 22, 'a');
	ShowList(11, 22, 'a', "BBB");
	ShowList();

	return 0;
}

运行结果

 

但是我们无法直接获取参数包中的每个参数，只能通过展开参数包的方式来获取，这是使用可变参数模板的一个主要特点，也是最大的难点 ，因为语法不支持使用 args[i] 这样方式获取可变参数，所以我们无法直接获取参数包中的每个参数

template
void ShowList(Args... args)
{
	//error，语法不支持
	for (int i = 0; i < sizeof...(args); i++)
	{
		cout << args[i] << " "; //打印参数包中的每个参数
	}
	cout << endl;
}

 这样编译是无法通过的，也不知道当时的大佬为什么不这样设计，这样设计很方便理解可变参数列表

1.3 参数包的展开方式

参数包的展开方式有：递归展开参数包、使用逗号表达式展开参数包

1.3.1 递归展开参数包

递归展开参数包的方式如下：

• 需要给函数模板增加一个模板参数T，这样就可以从接收到的参数包中分离出一个参数出来，参数包分离出的一个参数后给给新增加的模板参数T
• 打印完了第一个参数后，在函数模板中递归调用该函数模板，调用时传入剩下的参数包，这时又会从参数包中分离出一个参数给给另一个模板参数T
• 如此递归下去，每次分离出参数包中的一个参数，直到参数包中的所有参数都被取出来
• 为了终止递归，需要对该模板函数进行重载，重载一个新的模板函数，参数只有一个：T模板参数
• 当参数包中的个数为1时，调用函数就会去匹配我们重载的模板函数
• 这样递归就可以终止了

注意：这里的递归调用结束函数需要写成函数模板，因为我们并不知道最后一个参数是什么类型的 

测试代码

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

运行结果，可以获取并打印参数包的每一个参数

 

当然，也还可以重载以个无参的函数，这时重载的函数就不用加模板了，代码如下：

// 递归终止函数，重载ShowList函数
void ShowList()
{
	cout  << endl;
}
// 展开函数
template 
void ShowList(T value, Args... args)
{
	cout << value << " ";
	ShowList(args...);//将剩下参数包继续向下传
}
int main()
{
	ShowList(1);
	ShowList(1, 2);
	ShowList(1, 'A');
	ShowList(1, 'A', std::string("sort"));
	return 0;
}

注意：这里是当参数包中的个数为0时，调用函数就会去匹配我们重载的函数，结束递归

运行结果，可以获取并打印参数包的每一个参数

 

1.3.2 逗号表达式展开参数包

数组可以通过列表进行初始化，比如:

int a[] = {1,2,3,4,5};

 如果参数包中各个参数的类型都是整型，那么也可以把这个参数包放到列表当中初始化这个整型数组，此时参数包中参数就放到数组中了，例如：

//展开函数
template
void ShowList(Args... args)
{
	int arr[] = { args... }; //列表初始化
	//打印参数包中的各个参数
	for (auto e : arr)
	{
		cout << e << " ";
	}
	cout << endl;
}

int main()
{
	ShowList(1);
	ShowList(1, 2);
	ShowList(1, 2, 3);
	return 0;
}

运行结果

 

C++规定一个容器中存储的数据类型必须是相同的，因此如果这样写的话，那么调用 ShowList函数时传入的参数只能是整型的，并且还不能传入0个参数，因为数组的大小不能为0，因此我们还需要在此基础上借助逗号表达式来展开参数包

逗号表达式展开参数包的方式，不需要通过递归终止函数，是直接在 展开函数体（expand函数体）中展开的

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

这样一来，在执行逗号表达式时就会先调用处理函数处理对应的参数，然后再将逗号表达式中的最后一个整型值作为返回值来初始化整型数组

测试代码

template 
void PrintArg(T t)
{
	cout << t << " ";
}
//展开函数
template 
void ShowList(Args... args)
{
	int arr[] = { (PrintArg(args), 0)... };//列表初始化+逗号表达式
	cout << endl;
}
int main()
{
	ShowList(1);
	ShowList(1, 1.1);
	ShowList(1, 'A');
	ShowList(1, 'A', std::string("sort"));
	return 0;
}

运行结果

解释： 

• Printar函数不是一个递归终止函数，只是一个处理参数包中每一个参数的函数。
• 这种就地展开参数包的方式实现的关键是逗号表达式。
• 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数组的过程中就将参数包展开了，这个数组的目的纯粹是为了在数组构造的过程展开参数包

这时调用ShowList函数时就可以传入多个不同类型的参数了，但调用时仍然不能传入0个参数，因为数组的大小不能为0

如果想要支持传入0个参数，也可以重载一个无参的 ShowList函数

//支持无参调用
void ShowList()
{
	cout << endl;
}
//处理函数
template
void PrintArg(const T& t)
{
	cout << t << " ";
}
//展开函数
template
void ShowList(Args... args)
{
	int arr[] = { (PrintArg(args), 0)... }; //列表初始化+逗号表达式
	cout << endl;
}
int main()
{
	ShowList();
	ShowList(1);
	ShowList(1, 1.1);
	ShowList(1, 'A');
	ShowList(1, 'A', std::string("sort"));
	return 0;
}

运行结果，可以传入无参的

实际上我们也可以不用逗号表达式，因为这里的问题就是初始化整型数组时必须用整数，那我们可以将处理函数的返回值设置为整型，然后用这个返回值去初始化整型数组也是可以的

代码如下

//处理函数
template
int PrintArg(const T& t)
{
	cout << t << " ";
	return 0;
}
//展开函数
template
void ShowList(Args... args)
{
	int arr[] = { PrintArg(args)... }; //列表初始化
	cout << endl;
}
int main()
{
	ShowList();
	ShowList(1);
	ShowList(1, 1.1);
	ShowList(1, 'A');
	ShowList(1, 'A', std::string("sort"));
	return 0;
}

1.4 STL的emplace系列函数

C++11标准给STL中的容器增加emplace系列的插入接口

比如vector的push_back和 insert函数，都增加了对应的 emplace_back和 emplace函数

list容器的 push_front、push_back和 insert函数，都增加了对应的 emplace_front、emplace_back和 emplace函数

这些emplace版本的插入接口支持模板的可变参数和万能引用，比如list的emplace函数

emplace系列接口的使用方式与容器原有的插入接口的使用方式类似，但又有一些不同之处，这个不解释了，想知道自己可以进行查阅

----------------我是分割线---------------

文章到这里就结束了，下一篇即将更新