C++11：可变参数模板

目录

一、概述

二、场景

       1.深拷贝的类

        2.浅拷贝的类

---

C++使用指南

一、概述

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

        其中Args、args只是名称，可以自定义。

template <class ...XX>
void showlist(XX... xx)
{}

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

template <class ...Args>
void ShowList(Args... args)
{
}int main()
{ShowList();ShowList("abcd");ShowList(1,'A');ShowList(2,'Z',string("测试"));return 0;
}

---

        可变参数模板中，对于参数类型还有数量都是不可见的，因此我们可以自己实现函数来观察。注意，打印个数时，其他和可变参数模板相关的函数使用都较以往有所不同。

        判断参数的数量：

template <class ...Args>
void ShowList(Args... args)
{cout << sizeof...(args) << endl;
}int main()
{ShowList();ShowList("abcd");ShowList(1,'A');ShowList(2,'Z',string("测试"));return 0;
}

---

        但是不能打印参数，下面是错误的代码：

template <class ...Args>
void ShowList(Args... args)
{for (size_t i = 0; i < sizeof...(args); i++){cout << args[i] << " ";}cout << endl;
}

        在这里要区分一下，像这样打印参数，是在程序运行的时候，由于运行过程中变量i在变化，可以解析出参数。但是可变参数模板也是模板，而模板解析参数是在编译时进行的，也就是说，在编译结束时，参数包里的参数类型和个数都是要确定好的，不能等到运行时再解析参数。

        因此，为了解析参数，可变参数模板使用递归的方式展开参数包：

// 编译时递归的返回条件
void _ShowList()
{cout << endl;
}// 如果想依次拿到每个参数类型和值，编译时使用递归解析参数
template <class T, class ...Args>
void _ShowList(const T& val, Args... args)
{cout << val << " ";_ShowList(args...);
}template <class ...Args>
void ShowList(Args... args)
{_ShowList(args...);
}

        

---

        拿这一行代码举例，递归解析参数时，可变参数模板实例化出来的函数有下面这些：

ShowList(2,'Z',string("测试"));

//递归的结束条件
void _ShowList()
{cout << endl;
}//实例化以后，推演生成的过程
void ShowList(int val1, char ch, std::string s)
{_ShowList(val1, ch, s);
}void _ShowList(const int& val, char ch, std::string s)
{cout << val << " ";_ShowList(ch, s);
}void _ShowList(const char& val, std::string s)
{cout << val << " ";_ShowList(s);
}void _ShowList(const std::string& val)
{cout << val << " ";_ShowList();
}

二、场景

        可变参数模板到底在哪些地方使用？

        C++11在一些常见的容器中实现了带emplace这种字眼的函数：

        这个函数的功能和push_back类似，但是也有不同的地方。下面就来一一对比：

---

       1.深拷贝的类

        对于类中存在深拷贝，即在堆上开辟了空间的类，这种类中实现了移动构造函数。

        如果使用push_back和emplace_back的传参为有名对象，二者是没有任何区别的：

list<bit::string> lt1;bit::string s1("xxxx");
lt1.push_back(s1);
lt1.push_back(move(s1));
cout << "=============================================" << endl;bit::string s2("yyyy");
lt1.emplace_back(s2);
lt1.emplace_back(move(s2));
cout << "=============================================" << endl;

list<pair<bit::string, bit::string>> lt2;pair<bit::string, bit::string> kv1("xxxx", "yyyy");
lt2.push_back(kv1);
lt2.push_back(move(kv1));
cout << "=============================================" << endl;pair<bit::string, bit::string> kv2("xxxx", "yyyy");
lt2.emplace_back(kv2);
lt2.emplace_back(move(kv2));
cout << "=============================================" << endl;

 

---

        如果传参为匿名对象也是没有区别的，这里就不举例了。但是如果直接传对象参数的值，两者是有区别的：

lt1.push_back("xxxx");
lt1.emplace_back("xxxx");
cout << "=============================================" << endl;

 

        不难看出，emplace相比push，少了一次移动拷贝。

        而list的结点为pair这种复合类型时，push_back不能直接传参数的值。只能使用emplace_back，因为这些值会被识别为参数包，可以编译通过。而push_back的参数类型只能是对象的类型（左值或右值）：

lt2.emplace_back("xxxx", "yyyy");
cout << "=============================================" << endl;

---

        可以总结一点，对于存在移动构造函数的类，emplace_back相比push_back，在调用函数时直接传对象参数的值，可以减少一次移动构造函数的调用。

        2.浅拷贝的类

        如果一个类没有在堆上申请开辟空间，这样的类被称为浅拷贝的类，这种类中不存在移动构造函数。

---

        同样的，如果使用push_back和emplace_back传参为有名对象和匿名对象，二者是没有任何区别的：

list<Date> lt1;Date d1(2023, 1, 1);lt1.push_back(d1);
lt1.emplace_back(d1);cout << endl;lt1.push_back(Date(2023, 1, 1));
lt1.emplace_back(Date(2023, 1, 1));

---

          如果直接传对象参数的值，二者是有区别的：

list<Date> lt1;
lt1.push_back({ 2024,3,30 });// 不支持
//lt1.emplace_back({ 2024,3,30 });// 推荐
lt1.emplace_back(2024, 3, 30);

         

        可以看出，emplace_back相比之下，少了一次拷贝构造函数的调用。

        同时，要注意，在这种直接传具体的值，传参调用的时候，{值}这种写法是不支持emplace的，因为emplace的形参是参数包，而{值}会被识别为一个初始化列表类型，因此，在传参完成后，参数包被解析为一个初始化列表类型，不能用来构造三个参数的构造函数。

---

        经过上面分析，总结，可变参数模板的使用：

        在直接给出对象的值的传参情况下，emplace系列的函数，相比push函数有以下优势：

        如果是深拷贝的类，可以减少一次移动构造函数的调用

        如果是浅拷贝的类，可以减少一次拷贝构造函数的调用