🔥小叶-duck：个人主页
❄️个人专栏：《Data-Structure-Learning》《C++入门到进阶&自我学习过程记录》
《算法题讲解指南》--优选算法
《算法题讲解指南》--递归、搜索与回溯算法
《算法题讲解指南》--动态规划算法
✨未择之路，不须回头
已择之路，纵是荆棘遍野，亦作花海遨游
目录
[一. 值类别细分：左值、泛左值、纯右值与将亡值](#一. 值类别细分：左值、泛左值、纯右值与将亡值)
[二. 引用折叠：万能引用底层逻辑](#二. 引用折叠：万能引用底层逻辑)
[三. 完美转发：保持值类别属性的关键](#三. 完美转发：保持值类别属性的关键)
[四. 可变参数模板：支持任意参数的泛型编程](#四. 可变参数模板：支持任意参数的泛型编程)
[1、 基本语法](#1、 基本语法)
[五. 落地实践：emplace 系列接口的实现](#五. 落地实践：emplace 系列接口的实现)
[1、emplace_back 与 push_back 的区别](#1、emplace_back 与 push_back 的区别)
[2、模拟实现 list 的 emplace_back](#2、模拟实现 list 的 emplace_back)
前言
C++11 引入的右值引用和移动语义 解决了拷贝效率问题，但要真正灵活运用，还需掌握其延伸特性 ------ 引用折叠 、完美转发 和可变参数模板 。这三个特性是现代 C++ 泛型编程的基石 ，支撑了万能引用、emplace 系列接口等高频用法，也是理解 STL 容器底层优化的关键。
一. 值类别细分：左值、泛左值、纯右值与将亡值
C++11 以后对传统的 "左值 / 右值" 进行了更精细的划分：
- 泛左值（glvalue） ：包含左值和将亡值，核心特征是 "有标识（可寻址）"；
- 纯右值（prvalue） ：传统右值的核心部分，无标识、不可寻址 。指那些字面值常量 或者求值结果相当于字面值 或是一个不具名的临时对象(匿名对象)（如字面量10、表达式x+y、临时对象string("hello")）；
- 将亡值（xvalue）：返回右值引用的函数的调用表达式和转换为右值引用的转换函数的调用表达式（如 move(x)、static_cast<X&&>(x) ）；
- 核心关系：右值 = 纯右值 + 将亡值；泛左值 = 左值 + 将亡值。
二. 引用折叠：万能引用底层逻辑
C++ 不允许直接定义 "引用的引用" 如( int&& x )，但通过模版 或typedef 间接构成时，会触发引用折叠规则，这也是"万能引用"的核心原理。
cpp
typedef int& lref;
typedef int&& rref;
int n = 0;
lref& r1 = n; // r1 的类型是 int&
lref&& r2 = n; // r2 的类型是 int&
rref& r3 = n; // r3 的类型是 int&
rref&& r4 = 1; // r4 的类型是 int&&1、引用折叠的核心规则
- 右值引用的右值引用折叠为右值引用，其他所有组合均折叠为左值引用
以 int 为例：
| 原始类型组合 | 折叠后类型 |
|---|---|
| int& & | int& |
| int& && | int& |
| int&& & | int& |
| int&& && | int&& |
实际示例：
cpp
// 由于引用折叠限定，f1形参类型为左值引用，导致实例化以后总会是⼀个左值引用
template<class T>
void f1(T& x)
{
}
// 由于引用折叠限定，f2形参类型为右值引用，实例化后可以是左值引用，也可以是右值引用
template<class T>
void f2(T&& x)
{
}
int main()
{
// 没有折叠->实例化为void f1(int& x)
f1<int>(n);
//f1<int>(0); // 报错
// 折叠->实例化为void f1(int& x)
f1<int&>(n);
// f1<int&>(0); // 报错
// 折叠->实例化为void f1(int& x)
f1<int&&>(n);
// f1<int&&>(0); // 报错
// 折叠->实例化为void f1(const int& x)
f1<const int&>(n);
f1<const int&>(0); //const左值引用可以引用右值
// 折叠->实例化为void f1(const int& x)
f1<const int&&>(n);
f1<const int&&>(0);
// 没有折叠->实例化为void f2(int&& x)
// f2<int>(n); // 报错
f2<int>(move(n));
f2<int>(0);
// 折叠->实例化为void f2(int& x)
f2<int&>(n);
// f2<int&>(0); // 报错
// 折叠->实例化为void f2(int&& x)
// f2<int&&>(n); // 报错
f2<int&&>(0);
return 0;
}- f1我们就不用多说了，最终实例化都只会是一个左值引用
- f2 这样的函数模版中，T&& x 参数看起来是右值引用参数，但是由于引用折叠的规则，他传递左值时就是左值引用，传递右值时就是右值引用，有写地方也把这种函数模版的参数叫做万能引用。
cpp
// 万能引用-以int类型的为例
// 传左值时,T被自动推导为int&,最后就是左值引用
// 传右值时,T被自动推导为int,最后就是右值引用
template<class T>
void Function(T&& t)
{
int a = 0;
T x = a;
//x++;
cout << &a << endl;
cout << &x << endl << endl;
}
int main()
{
// 10是右值，推导出T为int，模板实例化为void Function(int&& t)
Function(10); // 右值
int a;
// a是左值，推导出T为int&，引用折叠，模板实例化为void Function(int& t)
//这里一定要注意并不是a是什么类型T就是什么类型，由于引用折叠的特性，T的类型推导一定会符合实参的情况，
//如果T为int则T&&就变成了int&&，则无法进行传参，而只有T为int&，T&&才是int&(引用折叠)实现传参
//并且通过打印的a和x的地址是相同的也能证明
Function(a); // 左值
// std::move(a)是右值，推导出T为int，模板实例化为void Function(int&& t)
Function(std::move(a)); // 右值
const int b = 8;
// a是左值，推导出T为const int&，引用折叠，模板实例化为void Function(const int& t)
// 所以Function内部会编译报错，x不能++
Function(b); // const 左值
// std::move(b)右值，推导出T为const int，模板实例化为void Function(const int&& t)
// 所以Function内部会编译报错，x不能++
Function(std::move(b)); // const 右值
return 0;
}
- Function(T&& t) 函数模版程序中，假设实参是 int 右值，模版参数T的推导就是 int ；实参是 int 左值，模版参数T的推导就是 int&，再结合引用折叠规则，就实现了实参是左值，实例化出左值引用版本形参Function，实参是右值，实例化出右值引用版本形参的Function。
2、万能引用的实际应用
模板参数 T&& 并非单纯的右值引用 ，结合引用折叠 后，可接收左值和右值，称为 "万能引用"：
- 当实参为左值（如int a），模板参数 T 推导为 int&，T&& 折叠为 int&（左值引用）；
- 当实参为右值（如10），模板参数 T 推导为 int，T&& 为 int&&（右值引用）。
我们拿前面学习list容器时模拟实现过的List.h 来改改看，虽然里面还涉及到完美转发 ，下面就会进行讲解，并且当讲完完美转发 会把模拟实现的 List 整体进行进一步的优化。(当然库里的push_back 并没有做以下万能引用的实现，只是通过实际的应用场景给大家展示"万能引用"的巧妙之处，因为库里存在emplace_back())：
三. 完美转发：保持值类别属性的关键
万能引用虽然可以接受任意值类别但右值变量本身是左值 ，直接传递会丢失原本的类别属性。所以我们需要完美转发 std::forward ，确保参数在传递过程中保持原本属性。
实际分析：
- 上面实现过的 Function(T&& t) 函数模版中，传左值实例化以后是左值引用的 Function 函数，传右值实例化以后是右值引用的 Function 函数。
- 但结合之前学过的，变量表达式都是左值属性 ，也就意味着一个右值被右值引用绑定后，右值引用变量表达式的属性是左值 ，也就是说 Function 函数中t 自身的属性是左值 ，那么我们把 t 传递给下一层函数 Fun 时，就会导致匹配的都是左值引用版本的 Fun 函数，这就和我们的预期不符，因为我们传的右值，希望所有的函数调用过程都是走的右值引用，所以这里我们想要保持 t 对象的属性，就需要使用完美转发来实现。
- 完美转发源码：通过 static_cast<T&&> 结合引用折叠，精准还原参数的原始值类别。
cpp
_EXPORT_STD template <class _Ty>
_NODISCARD _MSVC_INTRINSIC constexpr _Ty&& forward(remove_reference_t<_Ty>& _Arg) noexcept {
return static_cast<_Ty&&>(_Arg);
}
_EXPORT_STD template <class _Ty>
_NODISCARD _MSVC_INTRINSIC constexpr _Ty&& forward(remove_reference_t<_Ty>&& _Arg) noexcept {
static_assert(!is_lvalue_reference_v<_Ty>, "bad forward call");
return static_cast<_Ty&&>(_Arg);
}【完美转发】forward 本质是一个函数模板 ，主要还是通过引用折叠的方式实现，下面示例中**传递给Function的实参是右值，模板参数T（type）被推导为整型int，没有折叠，forward内部 t 被强转为右值引用返回；**传递给Function的实参是左值，T被推导为int&，引用折叠为左值引用，forward内部 t 被强转为左值引用返回。
cpp
//==============================完美转发==============================
void Fun(int& x) { cout << "左值引用" << endl; }
void Fun(const int& x) { cout << "const 左值引用" << endl; }
void Fun(int&& x) { cout << "右指引用" << endl; }
void Fun(const int&& x) { cout << "const 右值引用" << endl; }
//万能引用
template<class T>
void Function(T&& t)
{
Fun(forward<T>(t));
}
int main()
{
// 10是右值，推导出T为int，模板实例化为void Function(int&& t)
Function(10); // 右值
int a;
// a是左值，推导出T为int&，引用折叠，模板实例化为void Function(int& t)
Function(a); // 左值
// std::move(a)是右值，推导出T为int，模板实例化为void Function(int&& t)
Function(std::move(a)); // 右值
const int b = 8;
// a是左值，推导出T为const int&，引用折叠，模板实例化为void Function(const int&t)
Function(b); // const 左值
// std::move(b)右值，推导出T为const int，模板实例化为void Function(const int&& t)
Function(std::move(b)); // const 右值
return 0;
}
1、结合引用折叠和完美转发优化模拟实现List代码
在前面学习list容器时，我们对 list容器的模拟实现 进行了讲解，但当时由于还没有讲解C++11的知识，所以接口的模拟实现并没有涉及引用折叠和完美转发的概念，现在我们已经讲解了就可以进一步去优化当时模拟实现的list容器了。
cpp
//List.h
namespace xiaoye
{
class string
{
public:
typedef char* iterator;
typedef const char* const_iterator;
iterator begin()
{
return _str;
}
iterator end()
{
return _str + _size;
}
const_iterator begin() const
{
return _str;
}
const_iterator end() const
{
return _str + _size;
}
string(const char* str = "")
:_size(strlen(str))
, _capacity(_size)
{
cout << "string(char* str)-构造" << endl;
_str = new char[_capacity + 1];
strcpy(_str, str);
}
~string()
{
cout << "~string() -- 析构" << endl;
delete[] _str;
_str = nullptr;
_size = _capacity = 0;
}
void swap(string& s)
{
std::swap(_str, s._str);
std::swap(_size, s._size);
std::swap(_capacity, s._capacity);
}
// 拷贝构造
string(const string& s)
{
cout << "string(const string& s) -- 拷贝构造" << endl;
reserve(s._capacity); //拷贝构造需要额外再开辟空间进行拷贝数据
for (auto e : s)
{
push_back(e);
}
}
// 移动构造
string(string&& rs)
{
cout << "string(string&& s) -- 移动构造" << endl;
swap(rs); //移动构造只需要"掠夺"右值引用形参的资源即可实现构造
}
//拷贝赋值
string& operator=(const string& s)
{
cout << "string& operator=(const string& s) -- 拷贝赋值" << endl;
if (this != &s)
{
_str[0] = '\n';
_size = 0;
reserve(s._capacity); //拷贝赋值需要额外再开辟空间进行拷贝赋值数据
for (auto e : s)
{
push_back(e);
}
}
return *this;
}
//移动赋值
string& operator=(string&& rs)
{
cout << "string& operator=(string&& s) -- 移动赋值" << endl;
swap(rs); //移动赋值只需要"掠夺"右值引用形参的资源即可实现赋值
//并且不需要手动先删除旧数据，交换完后出了函数形参rs就会带着旧数据一起被销毁
return *this;
}
void reserve(size_t new_capacity)
{
if (new_capacity > _capacity)
{
char* tmp = new char[new_capacity + 1];
if (_str)//_str不为空才能进行delete，否则会报错
{
strcpy(tmp, _str);
delete[]_str;
}
_str = tmp;
_capacity = new_capacity;
}
}
char& operator[](size_t pos)
{
assert(pos < _size);
return _str[pos];
}
void push_back(char ch)
{
if (_size >= _capacity)
{
size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
reserve(newcapacity);
}
_str[_size] = ch;
++_size;
_str[_size] = '\0';
}
string& operator+=(char ch)
{
push_back(ch);
return *this;
}
const char* c_str() const
{
return _str;
}
size_t size() const
{
return _size;
}
size_t capacity() const
{
return _capacity;
}
private:
char* _str = nullptr;
size_t _size = 0;
size_t _capacity = 0;
};
//链表结点
template<class T>
struct ListNode
{
ListNode<T>* _next;
ListNode<T>* _prev;
T _data;
////左值引用版本的链表结点构造
//ListNode(const T& data = T())
// :_next(nullptr)
// , _prev(nullptr)
// , _data(data)
//{
//}
////右值引用版本的链表结点构造
//ListNode(T&& data)
// :_next(nullptr)
// , _prev(nullptr)
// , _data(forward<T>(data))
//{
//}
//无参构造
ListNode()
:_next(nullptr)
, _prev(nullptr)
, _data(T())
{
}
//万能引用
//需要注意的是当实现成万能引用时就必须传入一个参数，否则无法将模板参数X进行实例化
//而如果这样空链表的初始化就需要额外写一个无参的构造函数了
template<class X>
ListNode(X&& data)
:_next(nullptr)
, _prev(nullptr)
, _data(forward<X>(data)) //拷贝构造或者移动构造
//由于data自身属性是左值，为了成功调用合适的引用版本的构造我们就需要进行完美转发保持属性一致
{
}
};
//链表迭代器
template<class T, class Ref, class Ptr>
struct ListIterator
{
typedef ListNode<T> Node;
typedef ListIterator<T, Ref, Ptr> Self;
Node* _node;
ListIterator(Node* node)
:_node(node)
{
}
Self& operator++()
{
_node = _node->_next;
return *this;
}
Ref operator*()
{
return _node->_data;
}
Ptr operator->()
{
return &_node->_data;
}
bool operator!=(const Self& it)
{
return _node != it._node;
}
};
//链表
template<class T>
class list
{
typedef ListNode<T> Node;
public:
typedef ListIterator<T, T&, T*> iterator;
typedef ListIterator<T, const T&, const T*> const_iterator;
iterator begin()
{
return iterator(_head->_next);
}
iterator end()
{
return iterator(_head);
}
list()
{
_head = new Node();
_head->_next = _head;
_head->_prev = _head;
}
////左值引用版本的尾插
//void push_back(const T& x)
//{
// insert(end(), x);
//}
////右值引用版本的尾插
//void push_back(T&& x)
//{
// insert(end(), forward<T>(x));
//}
////这个并不是万能引用
////因为T是list的模板参数，当xiaoye::list<xiaoye::string>实例化后，参数T就已经确定为xiaoye::string了
////而并没有通过传入的实参类型为左值还是右值而进行二次推导的过程，
////所以我们不能只写这个右值引用版本，否则左值数据的插入就会找不到左值引用版本的尾插而报错
//万能引用
//在类模板list中在实现一个模板参数不同的函数模板，
//这样也就能保证了只有当我们调用插入函数时才能根据插入数据的类型进行实例化，进而对模板参数X进行类型推导
//这样也就将引用折叠和完美转发应用到list中了，不管传的是左值还是右值都只需要这一个函数模板即可
template<class X>
void push_back(X&& x)
{
insert(end(), forward<X>(x));
}
////左值引用版本的插入
//iterator insert(iterator pos, const T& x)
//{
// Node* cur = pos._node;
// Node* newnode = new Node(x);
// Node* prev = cur->_prev;
// // prev newnode cur
// prev->_next = newnode;
// newnode->_prev = prev;
// newnode->_next = cur;
// cur->_prev = newnode;
// return iterator(newnode);
//}
////右值引用版本的插入
//iterator insert(iterator pos, T && x)
//{
// Node* cur = pos._node;
// Node* newnode = new Node(forward<T>(x));
// Node* prev = cur->_prev;
// // prev newnode cur
// prev->_next = newnode;
// newnode->_prev = prev;
// newnode->_next = cur;
// cur->_prev = newnode;
// return iterator(newnode);
//}
//万能引用
template<class X>
iterator insert(iterator pos, X&& x)
{
Node* cur = pos._node;
Node* newnode = new Node(forward<X>(x));
//由于x自身属性是左值，创建节点时new一个Node，传入的数据也需要通过完美转发保持右值属性
Node* prev = cur->_prev;
// prev newnode cur
prev->_next = newnode;
newnode->_prev = prev;
newnode->_next = cur;
cur->_prev = newnode;
return iterator(newnode);
}
private:
Node* _head;
};
}
cpp
//Test.cpp
#include"List.h"
int main()
{
xiaoye::list<xiaoye::string> lt;
cout << "*************************" << endl;
xiaoye::string s1("111111111111111111111");
lt.push_back(s1);
cout << "*************************" << endl;
lt.push_back(xiaoye::string("22222222222222222222222222222"));
cout << "*************************" << endl;
lt.push_back("3333333333333333333333333333");
cout << "*************************" << endl;
lt.push_back(move(s1));
cout << "*************************" << endl;
return 0;
}注意的是：编译器的优化程度各不相同，可能和这里的结果有出入，如果对这里的结果怎么来的不清楚或者一知半解可以自己尝试通过调试看看是怎么执行代码的。
四. 可变参数模板：支持任意参数的泛型编程
C++11 引入可变参数模板 ，允许模板参数和函数参数的个数可变，解决了 "支持任意参数个数 / 类型" 的泛型需求，是emplace 系列接口 、printf 等函数的底层支撑。
- C+11 支持可变参数模版，也就是说支持可变数量参数的函数模版和类模版，可变数目的参数 被称为参数包 ，存在两种参数包：模版参数包 ，表示零个或多个模版参数 ；函数参数包 ：表示零个或多个函数参数。
cpp
template <class ...Args> void Func(Args... args) {}
template <class ...Args> void Func(Args&... args) {}
template <class ...Args> void Func(Args&&... args) {}- 我们用省略号 来指出一个模版参数或函数参数的表示一个包，在模版参数列表 中，class... 或 typename... 指出接下来的参数表示零或多个类型列表；在函数参数列表中，类型名后面跟 ... 指出接下来表示零个或多个形对象列表；函数参数包可以用左值引用或右值引用表示，跟前面普通模版一样，每个参数实例化时遵循引用折叠规则。
1、 基本语法
- 模板参数包 ：template<class... Args>（Args为零或多个类型）；
- 函数参数包 ：void Func(Args&&... args)（args为零或多个参数）；
- 包扩展 ：通过**...**触发参数包展开；
- 参数个数获取：sizeof...(args)（返回参数包中参数的个数）。
2、示例演示
cpp
//==============================可变参数模板==============================
template<class...Args>
void Print(Args&&...args) //万能引用，这样传左值还是右值都可以，编译器会自动推导Args类型
{
cout << sizeof...(args) << endl;
}
int main()
{
double x = 1.1;
Print(); // 包里有0个参数
Print(1); // 包里有1个参数
Print(x, string("xxxxx")); // 包里有2个参数
Print(2.2, string("xxxxx"), x); // 包里有3个参数
return 0;
}
3、参数包展开：编译时递归推导
- 对于一个参数包 ，我们除了能计算他的参数个数 ，我们能做的唯一的事情就是扩展它 ，当扩展一个包时，我们还要提供用于每个扩展元素的模式，扩展一个包就是将它分解为构成的元素，对每个元素应用模式，获得扩展后的列表。我们通过在模式的右边放一个省略号(...)来触发扩展操作。
可变参数模板的核心是"包扩展"，通过递归调用实现参数逐个解析（需定义递归终止条件）：
cpp
//==============================参数包扩展==============================
// 编译时递归推导解析参数
void ShowList()
{
// 编译器时递归的终止条件，参数包是0个时，直接匹配这个函数
cout << endl;
}
template<class T, class ...Args>
void ShowList(T x, Args... args)
{
//这是运行时的递归终止，而推导的过程是编译时，所以不能这样写
//if (sizeof..(args) == 0)
//{
// return;
//}
cout << x << " ";
// args是N个参数的参数包
// 调用ShowList,参数包的第一个传给x，剩下N-1传给第二个参数包
ShowList(args...);
}
template<class ...Args>
void Print(Args ...args)
{
// 解析参数包,递归推导
ShowList(args...);
}
int main()
{
Print();
Print(1);
Print(1, string("xxxxx"));
Print(1, string("xxxxx"), 2.2);
return 0;
}
底层的实现细节如下图所示：
五. 落地实践：emplace 系列接口的实现
C++11以后STL容器新增了empalce系列的接口，empalce系列的接口均为模板可变参数 ，功能兼容push和insert系列，但是empalce还支持新玩法，假设容器为container<T>，empalce还支持直接插入构造T对象的参数，这样有些场景会更高效一些，可以直接在容器空间上构造T对象。
1、emplace_back 与 push_back 的区别
- push_back：需先构造临时对象，再通过拷贝 / 移动构造到容器中；
- emplace_back：接收构造对象的参数包，直接在容器节点中构造对象，减少一次拷贝 / 移动。
string模拟实现(将调用函数进行打印便于观察)：
cpp
namespace xiaoye
{
class string
{
public:
typedef char* iterator;
typedef const char* const_iterator;
iterator begin()
{
return _str;
}
iterator end()
{
return _str + _size;
}
const_iterator begin() const
{
return _str;
}
const_iterator end() const
{
return _str + _size;
}
string(const char* str = "")
:_size(strlen(str))
, _capacity(_size)
{
cout << "string(char* str)-构造" << endl;
_str = new char[_capacity + 1];
strcpy(_str, str);
}
~string()
{
//cout << "~string() -- 析构" << endl;
delete[] _str;
_str = nullptr;
_size = _capacity = 0;
}
void swap(string& s)
{
std::swap(_str, s._str);
std::swap(_size, s._size);
std::swap(_capacity, s._capacity);
}
// 拷贝构造
string(const string& s)
{
cout << "string(const string& s) -- 拷贝构造" << endl;
reserve(s._capacity); //拷贝构造需要额外再开辟空间进行拷贝数据
for (auto e : s)
{
push_back(e);
}
}
// 移动构造
string(string&& rs)
{
cout << "string(string&& s) -- 移动构造" << endl;
swap(rs); //移动构造只需要"掠夺"右值引用形参的资源即可实现构造
}
//拷贝赋值
string& operator=(const string& s)
{
cout << "string& operator=(const string& s) -- 拷贝赋值" << endl;
if (this != &s)
{
_str[0] = '\n';
_size = 0;
reserve(s._capacity); //拷贝赋值需要额外再开辟空间进行拷贝赋值数据
for (auto e : s)
{
push_back(e);
}
}
return *this;
}
//移动赋值
string& operator=(string&& rs)
{
cout << "string& operator=(string&& s) -- 移动赋值" << endl;
swap(rs); //移动赋值只需要"掠夺"右值引用形参的资源即可实现赋值
//并且不需要手动先删除旧数据，交换完后出了函数形参rs就会带着旧数据一起被销毁
return *this;
}
void reserve(size_t new_capacity)
{
if (new_capacity > _capacity)
{
char* tmp = new char[new_capacity + 1];
if (_str)//_str不为空才能进行delete，否则会报错
{
strcpy(tmp, _str);
delete[]_str;
}
_str = tmp;
_capacity = new_capacity;
}
}
char& operator[](size_t pos)
{
assert(pos < _size);
return _str[pos];
}
void push_back(char ch)
{
if (_size >= _capacity)
{
size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
reserve(newcapacity);
}
_str[_size] = ch;
++_size;
_str[_size] = '\0';
}
string& operator+=(char ch)
{
push_back(ch);
return *this;
}
const char* c_str() const
{
return _str;
}
size_t size() const
{
return _size;
}
size_t capacity() const
{
return _capacity;
}
private:
char* _str = nullptr;
size_t _size = 0;
size_t _capacity = 0;
};
}实际操作：
- 场景一：基础场景( list<string> ) && 减少一次移动构造
cpp
//==============================empalce系列接口==============================
#include<list>
// emplace_back总体而言是更加高效的，推荐以后使用emplace系列替代insert和push系列
int main()
{
list<xiaoye::string> lt;
// 传左值,跟push_back一样,走拷贝构造
xiaoye::string s1("1111111111");
lt.emplace_back(s1);
cout << "************************************" << endl;
// 右值,跟push_back一样,走移动构造
lt.emplace_back(move(s1));
cout << "************************************" << endl;
// 直接把构造string参数包往下传，直接用string参数包构造string
// 这里达到的效果是push_back做不到的
lt.push_back("1111111111");
cout << "************************************" << endl;
lt.emplace_back("1111111111");
cout << "************************************" << endl;
return 0;
}
- 场景二：进阶场景( list<pair> / list<Date>) && 减少一次拷贝构造
cpp
#include<list>
struct Date
{
public:
Date(int y, int m, int d)
:_y(y)
, _m(m)
, _d(d)
{
cout << "Date() 构造" << endl;
}
Date(const Date& d)
:_y(d._y)
, _m(d._m)
, _d(d._d)
{
cout << "Date(const Date& d) 拷贝构造" << endl;
}
Date(Date&& d)
:_y(d._y)
, _m(d._m)
, _d(d._d)
{
cout << "Date(Date&& d) 移动构造" << endl;
}
private:
int _y = 1;
int _m = 1;
int _d = 1;
};
int main()
{
list<pair<xiaoye::string, int>> lt1;
// 跟push_back一样
// 构造pair + 拷贝/移动构造pair到list的节点中data上
pair<xiaoye::string, int> kv("苹果", 1);
lt1.emplace_back(kv);
cout << "****************************" << endl;
// 跟push_back一样
lt1.emplace_back(move(kv));
cout << "****************************" << endl;
// 直接把构造pair参数包往下传，直接用pair参数包构造pair
// 这里达到的效果是push_back做不到的
lt1.emplace_back("苹果", 1);
//lt1.emplace_back({ "苹果", 1 });
//这样传是错误的，原因我们需要结合{}来解释：
//首先我们要知道为什么 { } 可以在push_back中使用？
//因为push_back中已经确定了函数参数的类型就是pair，所以传入的 {} 可以进行隐式类型转换成pair
//而emplace_back是一个可变参数的函数模板，而这个可变模板参数Args只有确定传入的数据类型才会进行推导类型
//而 {} 又必须要知道函数参数类型是什么才能进行隐式类型转换，导致两边都无法进行
//那为什么直接传入两个独立数据就可以呢？原因就在于直接传入两个独立数据，
//Arges就可以推导成int, int，那么就可以调用pair的构造函数pair (const first_type& a, const second_type& b);
cout << "****************************" << endl;
//lt1.push_back("苹果", 1);
// error，要传 pair 或者 {}进行隐式类型转换成pair的值
lt1.push_back({ "苹果", 1 });
cout << "****************************" << endl;
list<Date> lt;
// 构造 + 拷贝构造
Date d1{ 2026,4,14 };
lt.push_back(d1);
cout << "************************************" << endl;
// 构造(临时对象) + 移动构造
lt.push_back({ 2026,4,14 });
cout << "************************************" << endl;
// 传构造Dtae的参数，传给形参参数包，参数包往下不断传递，最后直接构造到链表节点上
// 直接构造
lt.emplace_back(2026,4,14);
//lt.emplace_back({ 2026,4,14 });//error，同理和上面的pair的原因一样
return 0;
}
2、模拟实现 list 的 emplace_back
关键代码：
cpp
namespace xiaoye
{
//链表结点
template<class T>
struct ListNode
{
ListNode<T>* _next;
ListNode<T>* _prev;
T _data;
ListNode(T&& data)
:_next(nullptr)
, _prev(nullptr)
, _data(move(data)) // 移动构造或拷贝构造
{
}
template<class... Args>
ListNode(Args&&... args)
: _next(nullptr)
, _prev(nullptr)
, _data(std::forward<Args>(args)...)
{
}
};
//链表迭代器
template<class T, class Ref, class Ptr>
struct ListIterator
{
typedef ListNode<T> Node;
typedef ListIterator<T, Ref, Ptr> Self;
Node* _node;
ListIterator(Node* node)
:_node(node)
{
}
Self& operator++()
{
_node = _node->_next;
return *this;
}
Ref operator*()
{
return _node->_data;
}
Ptr operator->()
{
return &_node->_data;
}
bool operator!=(const Self& it)
{
return _node != it._node;
}
};
//链表
template<class T>
class list
{
typedef ListNode<T> Node;
public:
typedef ListIterator<T, T&, T*> iterator;
typedef ListIterator<T, const T&, const T*> const_iterator;
iterator begin()
{
return iterator(_head->_next);
}
iterator end()
{
return iterator(_head);
}
list()
{
_head = new Node();
_head->_next = _head;
_head->_prev = _head;
}
//左值引用版本的尾插
void push_back(const T& x)
{
insert(end(), x);
}
//右值引用版本的尾插
void push_back(T&& x)
{
insert(end(), forward<T>(x));
}
template<class...Args>
void emplace_back(Args&&...args)
{
insert(end(), std::forward<Args>(args)...);
}
// 原理：本质编译器根据可变参数模板生成对应参数的函数
/*void emplace_back(string& s)
{
insert(end(), std::forward<string>(s));
}
void emplace_back(string&& s)
{
insert(end(), std::forward<string>(s));
}
void emplace_back(const char* s)
{
insert(end(), std::forward<const char*>(s));//这个就会直接调用string的构造函数
}
*/
//左值引用版本的插入
iterator insert(iterator pos, const T& x)
{
Node* cur = pos._node;
Node* newnode = new Node(x);
Node* prev = cur->_prev;
// prev newnode cur
prev->_next = newnode;
newnode->_prev = prev;
newnode->_next = cur;
cur->_prev = newnode;
return iterator(newnode);
}
//右值引用版本的插入
iterator insert(iterator pos, T && x)
{
Node* cur = pos._node;
Node* newnode = new Node(forward<T>(x));
Node* prev = cur->_prev;
// prev newnode cur
prev->_next = newnode;
newnode->_prev = prev;
newnode->_next = cur;
cur->_prev = newnode;
return iterator(newnode);
}
template<class... Args>
iterator insert(iterator pos, Args&&... args)
{
Node* cur = pos._node;
Node* newnode = new Node(std::forward<Args>(args)...);
Node* prev = cur->_prev;
// prev newnode cur
prev->_next = newnode;
newnode->_prev = prev;
newnode->_next = cur;
cur->_prev = newnode;
return iterator(newnode);
}
private:
Node* _head;
};
}测试代码：
cpp
//==============================模拟实现 list 的 emplace_back==============================
int main()
{
xiaoye::list<xiaoye::string> lt;
xiaoye::string s1("111111111111");
lt.emplace_back(s1);
cout << "*********************************" << endl;
lt.emplace_back(move(s1));
cout << "*********************************" << endl;
lt.emplace_back("111111111111");
cout << "*********************************" << endl;
xiaoye::list<pair<xiaoye::string, int>> lt1;
pair<xiaoye::string, int> kv("苹果", 1);
lt1.emplace_back(kv);
cout << "*********************************" << endl;
lt1.emplace_back(move(kv));
cout << "*********************************" << endl;
////////////////////////////////////////////////////////////////////
lt1.emplace_back("苹果", 1);
cout << "*********************************" << endl;
return 0;
}
结束语
到此，C++11的引用折叠、完美转发与可变参数模板就讲解完了。**引用折叠、完美转发和可变参数模板是 C++11 泛型编程的 "三剑客"，看似抽象，但落地场景十分具体 --- emplace 接口、万能引用、函数参数转发等高频用法都基于这些特性。。实际开发中，建议优先使用emplace_back 替代 push_back，合理运用万能引用和完美转发简化代码，同时注意值类别的区分，避免因转发错误导致性能的无端损耗。**希望对大家学习C++能有所收获！
C++参考文档：
https://legacy.cplusplus.com/reference/
https://zh.cppreference.com/w/cpp
https://en.cppreference.com/w/