35_「C++11」晦涩难懂语法：可变参数模板
「前言」文章的大致内容是可变参数模板表达式。
可变参数模板
1.1 概念
在C语言阶段，我们已经接触过可变参数，比如 scand、printf 等等。
这里的 ... 就是可变参数列表，这也是 scanf 和 printf 可以接受多个参数的原因：使用了可变参数列表，但是scanf 和 printf 的可变参数是函数参数的可变参数，并不是模板的可变参数。
C++11 的新特性可变参数模板能够让您创建可以接受可变参数的函数模板和类模板，相比 C++98/03，类模版和函数模版中只能含固定数量的模版参数，可变模版参数无疑是一个巨大的改进。但是由于可变模版参数比较抽象（晦涩难懂），使用起来需要一定的技巧。
下面只讲解可变参数模板。
1.2 可变参数模板定义
下面就是一个基本可变参数的函数模板
// Args是一个模板参数包，args是一个函数形参参数包
// 声明一个参数包Args...args，这个参数包中可以包含0到任意个模板参数。
template <class ...Args>
void ShowList(Args... args)
{}
- 上面的参数 args 前面有省略号，所以它就是一个可变模版参数，我们把带省略号的参数称为 “参数包”，它里面包含了0到N（N>=0）个模版参数。Args是一个模板参数包，args是一个函数形参参数包。
- 我们无法直接获取参数包 args 中的每个参数的，只能通过展开参数包的方式来获取参数包中的每个参数，这是使用可变模版参数的一个主要特点，也是最大的难点，即如何展开可变模版参数。
可以在函数模板中通过 sizeof 计算参数包中参数的个数，代码如下。
注意：sizeof 后面也需要加上参数列表 ... ，不加直接报错
template<class ...Args>
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;
}
运行结果
1
2
3
4
0
但是我们无法直接获取参数包中的每个参数，只能通过展开参数包的方式来获取，这是使用可变参数模板的一个主要特点，也是最大的难点 ，因为语法不支持使用 args[i] 这样方式获取可变参数，所以我们无法直接获取参数包中的每个参数。
template<class ...Args>
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 <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, 2);
ShowList(1, 'A');
ShowList(1, 'A', std::string("sort"));
return 0;
}
运行结果，可以获取并打印参数包的每一个参数
1
1 2
1 A
1 A sort
当然，也还可以重载以个无参的函数，这时重载的函数就不用加模板了，代码如下：
// 递归终止函数，重载ShowList函数
void ShowList()
{
cout << endl;
}
// 展开函数
template <class T, class ...Args>
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
1 2
1 A
1 A sort
1.3.2 逗号表达式展开参数包
数组可以通过列表进行初始化，比如:
int a[] = {1,2,3,4,5};
如果参数包中各个参数的类型都是整型，那么也可以把这个参数包放到列表当中初始化这个整型数组，此时参数包中参数就放到数组中了，例如：
//展开函数
template<class ...Args>
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;
}
运行结果
1
1 2
1 2 3
C++ 规定一个容器中存储的数据类型必须是相同的，因此如果这样写的话，那么调用 ShowList函数时传入的参数只能是整型的，并且还不能传入0个参数，因为数组的大小不能为0，因此我们还需要在此基础上借助逗号表达式来展开参数包。
逗号表达式展开参数包的方式，不需要通过递归终止函数，是直接在 展开函数体（expand函数体）中展开的
- 逗号表达式会从左到右依次计算各个表达式，并且将最后一个表达式的值作为返回值进行返回。
- 将逗号表达式的最后一个表达式设置为一个整型值，确保逗号表达式返回的是一个整型值。
- 将处理参数包中参数的动作封装成一个函数，将该函数的调用作为逗号表达式的第一个表达式。
这样一来，在执行逗号表达式时就会先调用处理函数处理对应的参数，然后再将逗号表达式中的最后一个整型值作为返回值来初始化整型数组。
测试代码
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, 1.1);
ShowList(1, 'A');
ShowList(1, 'A', std::string("sort"));
return 0;
}
运行结果
1
1 1.1
1 A
1 A sort
解释：
- 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<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();
ShowList(1);
ShowList(1, 1.1);
ShowList(1, 'A');
ShowList(1, 'A', std::string("sort"));
return 0;
}
运行结果，可以传入无参的。
实际上我们也可以不用逗号表达式，因为这里的问题就是初始化整型数组时必须用整数，那我们可以将处理函数的返回值设置为整型，然后用这个返回值去初始化整型数组也是可以的。
代码如下
//处理函数
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;
}
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 系列接口的使用方式与容器原有的插入接口的使用方式类似，但又有一些不同之处。
举例 vector 的，其他都类似。
insert 和 emplace 的区别
- insert 函数用于在 vector 的指定位置插入一个或多个元素。它可以插入单个元素的，也可以插入一段区间的元素。插入时，会将插入位置及之后的元素向后移动，为新插入的元素腾出空间。
- emplace 和 insert 类似，也是在指定位置插入元素，但它是就地构造元素，而不是插入已有的元素副本。这样可以避免不必要的拷贝操作，提高效率。
使用 insert 函数：
#include <iostream>
#include <vector>
using namespace std;
class MyClass
{
public:
MyClass(int a) : data(a) { cout << "Constructor called." << endl; }
MyClass(const MyClass& other)
{
cout << "Copy constructor called." << endl;
data = other.data;
}
int data;
};
int main()
{
std::vector<MyClass> arr;
arr.push_back(MyClass(3));
cout << "------1" << endl;
MyClass obj(5);
cout << "------2" << endl;
arr.insert(arr.begin() + 1, obj);
for (auto& it : arr)
cout << it.data << " ";
cout << endl;
return 0;
}
运行结果，insert 操作会调用 MyClass 的拷贝构造函数，因为它是将 obj 的副本插入到vector中，第七行就是 insert 调用的拷贝构造函数。
注意：第六行是 vector 扩容进行的拷贝时调用的（容量1扩容为2，原来有一个元素，拷贝一次）。
Constructor called.
Copy constructor called.
------1
Constructor called.
------2
Copy constructor called.
Copy constructor called.
3 5
使用 emplace 函数：
int main()
{
std::vector<MyClass> arr;
arr.push_back(MyClass(3));
cout << "------1" << endl;
MyClass obj(5);
cout << "------2" << endl;
arr.insert(arr.begin() + 1, obj);
for (auto& it : arr)
cout << it.data << " ";
cout << endl;
cout << "------3" << endl;
// emplace
arr.emplace(arr.begin() + 2, 6);
for (auto& it : arr)
cout << it.data << " ";
return 0;
}
运行结果，这里 emplace 操作直接在 vector 中指定位置就地构造了一个 MyClass 对象，参数6直接用于构造新对象，避免了拷贝操作，第十行调用了一次构造函数。
注意：11行和12行是vector 扩容进行的拷贝时调用的。
Constructor called.
Copy constructor called.
------1
Constructor called.
------2
Copy constructor called.
Copy constructor called.
3 5
------3
Constructor called.
Copy constructor called.
Copy constructor called.
3 5 6
emplace_back 也是如此，直接在目标位置构造元素，避免了额外的复制或移动操作。
--------------- END ---------------
「 作者 」 枫叶先生
「 更新 」 2023.4.19
「 声明 」 余之才疏学浅，故所撰文疏漏难免，
或有谬误或不准确之处，敬请读者批评指正。
35_「C++11」晦涩难懂语法：可变参数模板
http://114.132.213.38:6250/archives/2f574155-c72f-464c-ad62-6abee21ac11f
评论