【C++】C++11可变参数模板

樊梓慕 2024-07-24 08:35:03 阅读 96

👀樊梓慕:个人主页

 🎥个人专栏:《C语言》《数据结构》《蓝桥杯试题》《LeetCode刷题笔记》《实训项目》《C++》《Linux》《算法》

🌝每一个不曾起舞的日子,都是对生命的辜负


目录

前言

可变参数模板的定义方式

可变参数模板的使用 

编译时递归展开参数包

可变参数模板的应用:emplace系列函数

对比emplace_back与push_back

emplace系列真正的优势在于浅拷贝的类

总结

List类增添模拟实现emplace系列函数

构造

emplace_back()

emplace()


前言

其实我们之前经常使用可变参数模板,C语言的printf函数大家一定非常熟悉,其实这就是一种可变参数模板:

那么在C++11引入可变参数模板的设计可以带来什么变化呢?让我们一起来学习下吧! 


欢迎大家📂收藏📂以便未来做题时可以快速找到思路,巧妙的方法可以事半功倍。 

=========================================================================

GITEE相关代码:🌟樊飞 (fanfei_c) - Gitee.com🌟

=========================================================================


可变参数模板的定义方式

<code>template<class ...Args>

返回类型 函数名(Args... args)

{

//函数体

}

例如:

// Args是一个模板参数包,args是一个函数形参参数包

// 声明一个参数包Args...args,这个参数包中可以包含0到任意个模板参数。

template <class ...Args>

void ShowList(Args... args)

{}

模板参数Args前面有『 省略号』,代表它是一个可变模板参数,我们把带省略号的参数称为参数包,参数包里面可以包含0到任意个模板参数,而args则是一个函数形参参数包。模板参数包Args和函数形参参数包args的名字可以任意指定,并不是说必须叫做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:

<code>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,中间省略了拷贝的过程;

比如:

<code>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的优势显现不出来。

比如:

<code>int main()

{

std::list<F::string> lt1;

lt1.push_back("xxxx");

cout << "=============================================" << endl;

lt1.emplace_back("xxxx");

return 0;

}

emplace真正的优势在于浅拷贝的类,可以节省一个拷贝过程:

比如日期类:

<code>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中就相当于把参数又封装起来了:

<code>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系列函数

构造

<code>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;

}


=========================================================================

如果你对该系列文章有兴趣的话,欢迎持续关注博主动态,博主会持续输出优质内容

🍎博主很需要大家的支持,你的支持是我创作的不竭动力🍎

🌟~ 点赞收藏+关注 ~🌟

=========================================================================



声明

本文内容仅代表作者观点,或转载于其他网站,本站不以此文作为商业用途
如有涉及侵权,请联系本站进行删除
转载本站原创文章,请注明来源及作者。