【C++】C++11可变参数模板
时间：2024-04-10 07:55:39 来源：网络cs 作者：康由 栏目：防关联工具 阅读：
👀樊梓慕：个人主页
🎥个人专栏：《C语言》《数据结构》《蓝桥杯试题》《LeetCode刷题笔记》《实训项目》《C++》《Linux》《算法》
🌝每一个不曾起舞的日子，都是对生命的辜负
目录
前言
可变参数模板的定义方式
可变参数模板的使用
编译时递归展开参数包
可变参数模板的应用：emplace系列函数
对比emplace_back与push_back
emplace系列真正的优势在于浅拷贝的类
总结
List类增添模拟实现emplace系列函数
构造
emplace_back()
emplace()
前言
其实我们之前经常使用可变参数模板，C语言的printf函数大家一定非常熟悉，其实这就是一种可变参数模板：
那么在C++11引入可变参数模板的设计可以带来什么变化呢？让我们一起来学习下吧！
欢迎大家📂收藏📂以便未来做题时可以快速找到思路，巧妙的方法可以事半功倍。
=========================================================================
GITEE相关代码：🌟樊飞 (fanfei_c) - Gitee.com🌟
=========================================================================
可变参数模板的定义方式
template<class ...Args>返回类型 函数名(Args... args){ //函数体}例如：
// Args是一个模板参数包，args是一个函数形参参数包// 声明一个参数包Args...args，这个参数包中可以包含0到任意个模板参数。template <class ...Args>void ShowList(Args... args){}可变参数模板的使用
此时我们可以传入任意多个参数了，并且这些参数可以是不同类型的：
int main(){ ShowList(); ShowList(1); ShowList(1, 'A'); ShowList(1, 'A', string("hello")); return 0;}我们可以在函数模板中通过sizeof计算参数包中参数的个数：
template<class ...Args>void ShowList(Args... args){ cout << sizeof...(args) << endl; //获取参数包中参数的个数}但是，我们如何解析参数包中的内容呢？
我们可不可以这样获取？
template<class ...Args>void ShowList(Args... args){ for (int i = 0; i < sizeof...(args); i++) { cout << args[i] << " "; } cout << endl;}答案是不可以！
注意：可变参数模板，既然是模板就是编译时解析，就不能使用如上这种运行时解析的逻辑获取。
因此要获取参数包中的各个参数，可以通过『 编译时递归』的方式解析数据。
编译时递归展开参数包
如何实现编译时递归呢？那肯定是利用编译器的解析机制，我们给函数模板增加一个模板参数，每次从接收到的参数包中剥离出来一个参数，然后在函数模板中递归调用该函数模板，调用时传入剩下的参数包，如此递归下去，每次剥离出参数包中的一个参数，直到参数包中的所有参数都被取出来。
比如：
//展开函数template<class T, class ...Args>void _ShowList(T value, Args... args){cout << value << " "; _ShowList(args...);//递归}那么如何终止递归呢？
我们每次都剥离下一个参数，最后必然就没有参数了，那么根据编译器的『最匹配原则 』，我们可以实现一个『 无参』的递归终止函数：
//递归终止函数void _ShowList(){cout << endl;}//展开函数template<class T, class ...Args>void _ShowList(T value, Args... args){cout << value << " ";_ShowList(args...); //递归}然后再封装起来如下：
//递归终止函数void _ShowList(){cout << endl;}//展开函数template<class T, class ...Args>void _ShowList(T value, Args... args){cout << value << " "; //打印传入的若干参数中的第一个参数_ShowList(args...); //将剩下参数继续向下传}//供外部调用的函数template<class ...Args>void ShowList(Args... args){_ShowList(args...);}这种『 编译时递归』的思想可谓是非常新奇，值得我们学习。
可变参数模板的应用：emplace系列函数
对比emplace_back与push_back
还记得么？
&&这里为万能引用，不是单纯的右值引用。
相对于push_back，emplace_back支持万能引用和可变参数模板。
他们都是尾插『 一个』数据，注意这里不要看可变参数模板就以为是插入几个值，这里是『 类型』。
对比push_back与emplace_back：
int main(){std::list<pair<F::string, F::string>> lt2;pair<F::string, F::string> kv1("xxxx", "yyyy");lt2.push_back(kv1);lt2.push_back(move(kv1));cout << "=============================================" << endl;pair<F::string, F::string> kv2("xxxx", "yyyy");lt2.emplace_back(kv2);lt2.emplace_back(move(kv2));cout << "=============================================" << endl;return 0;}对比发现也没有区别？
其实emplace_back和push_back真正的区别在于：
push_back需要先用参数构造pair这个对象，然后再将这个对象拷贝给链表节点中的pair；
而emplace_back是直接拿着参数去构造链表节点中的pair，中间省略了拷贝的过程；
比如：
int main(){std::list<pair<F::string, F::string>> lt2;pair<F::string, F::string> kv1("xxxx", "yyyy");lt2.push_back(kv1);lt2.push_back(move(kv1));cout << "=============================================" << endl;pair<F::string, F::string> kv2("xxxx", "yyyy");lt2.emplace_back(kv2);lt2.emplace_back(move(kv2));cout << "=============================================" << endl;lt2.emplace_back("xxxx", "yyyy");cout << "=============================================" << endl;return 0;}
emplace系列真正的优势在于浅拷贝的类
因为对于深拷贝的且实现了移动构造的类来说，移动构造代价很小，emplace的优势显现不出来。
比如：
int main(){std::list<F::string> lt1;lt1.push_back("xxxx");cout << "=============================================" << endl;lt1.emplace_back("xxxx");return 0;}
emplace真正的优势在于浅拷贝的类，可以节省一个拷贝过程：
比如日期类：
class Date{public://构造Date(int year, int month, int day):_year(year), _month(month), _day(day){cout << "Date(int year, int month, int day)" << endl;}//拷贝构造Date(const Date& d):_year(d._year), _month(d._month), _day(d._day){cout << "Date(const Date& d)" << endl;}private:int _year = 1;int _month = 1;int _day = 1;};同样尾插：
int main(){std::list<Date> lt1;lt1.push_back({ 2024,3,30 });cout << "=============================================" << endl;lt1.emplace_back(2024, 3, 30);return 0;}
注意：push_back支持initializer_list作为参数是因为push_back的参数就是模板类型，所以他知道插入的对象是Date类型，就直接走多参数的隐式类型转换构造一个Date对象了，而emplace不支持initializer_list作为构造参数，因为emplace需要可变参数模板去底层构造list节点，你放到initializer_list中就相当于把参数又封装起来了：
int main(){std::list<Date> lt1;lt1.push_back({ 2024,3,30 });// 不支持//lt1.emplace_back({ 2024,3,30 });// 正确写法lt1.emplace_back(2024, 3, 30);return 0;}
如果给emplace的参数是现成的对象（不管有名对象还是匿名对象），那emplace就没有任何优势了：
int main(){std::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));return 0;}
总结
emplace系列接口使用需要直接传入参数包才能体现emplace接口的价值与意义，因为emplace系列接口真正高效的情况是传入参数包的时候，直接通过参数包构造出对象，避免了中途的一次拷贝。所以emplace系列接口并不是在所有场景下都比原有的插入接口高效，如果传入的是对象（不管有名还是匿名），那么emplace系列接口的效率其实和原有的插入接口的效率是一样的。以上两条告诉我们：以后使用emplace就直接传参数包，不要构造了对象后再将该对象作为参数传给emplace，直接传参数包才是emplace存在的价值和意义。并且emplace系列接口对于深拷贝的且实现了移动构造的类意义不大，因为移动构造的代价很小，emplace带来的效率提升并不会很明显，emplace系列接口对于浅拷贝的类可以节省拷贝（拷贝代价高，并且浅拷贝的类没有移动构造），所以emplace对于浅拷贝的类插入提升很明显。List类增添模拟实现emplace系列函数
构造
template<class ...Args>ListNode(Args&&... args) : _next(nullptr) , _prev(nullptr) , _data(forward<Args>(args)...){}emplace_back()
template<class ...Args>void emplace_back(Args&&... args){ emplace(end(), forward<Args>(args)...);}emplace()
template<class ...Args>iterator emplace(iterator pos, Args&&... args){ Node* cur = pos._node; Node* prev = cur->_prev; Node* newnode = new Node(forward<Args>(args)...); prev->_next = newnode; newnode->_prev = prev; newnode->_next = cur; cur->_prev = newnode; //return iterator(newnode); return newnode;}=========================================================================
如果你对该系列文章有兴趣的话，欢迎持续关注博主动态，博主会持续输出优质内容
🍎博主很需要大家的支持，你的支持是我创作的不竭动力🍎
🌟~ 点赞收藏＋关注 ~🌟
=========================================================================
本文链接：https://www.kjpai.cn/news/2024-04-10/156345.html，文章来源：网络cs，作者：康由，版权归作者所有，如需转载请注明来源和作者，否则将追究法律责任！