【C++11】右值引用+移动语义+完美转发
右值引用+移动语义+完美转发
- 右值引用、移动语义和完美转发
- github地址
- 前言
- 一、左值和右值
- 1. 左值
- 2. 右值
- 二、左值引用和右值引用
- 1. 左值引用 vs 右值引用
- 2. const 左值引用给右值取别名
- 3. 右值引用不能直接给左值取别名
- 4. std::move()的作用
- 5. 总结
- 三、右值引用解决左值引用的缺陷
- 1. 左值引用的价值与缺陷
- 2. 传值返回时编译器RVO的优化
- 3. 无法优化的场景
- 4. 左值和右值的参数匹配
- 四、右值引用的移动语义
- 1. 移动赋值
- 认识移动赋值
- 有RVO时的移动赋值
- 无RVO时的移动赋值
- 2. 移动构造
- 认识移动构造
- 编译器不做优化时的移动构造
- 编译器优化后的移动构造
- 五、右值引用和移动语义的应用场景
- 1. 自定义类型中深拷贝的类，必须传值返回的场景
- 代码片段
- 运行结果分析
- 移动语义的核心：资源抢占
- 2. STL 容器的插入接口
- C++98中的调用过程
- C++11中的配合move产生右值
- 右值的日常写法
- 深拷贝和移动拷贝的对比
- 六、引用折叠与万能引用
- 1. 引用折叠
- 2. 模板的万能引用
- 七、完美转发及其应用
- 1. 左值引用和右值引用本身均是左值
- 2. 完美转发及其应用
- 什么是完美转发？
- 为什么需要完美转发？
- 如何实现完美转发？
- 完美转发保持对象的原生属性
- 总结完美转发的使用：
- 3. 完美转发的应用场景
- 八、std::move VS std::forward
- 1. 右值引用 对比 万能引用
- 2. std::move 与 std::forward 的使用场景总结：
- 结语
右值引用、移动语义和完美转发
github地址
有梦想的电信狗
前言
在传统的 C++ 中，引用机制主要用于避免拷贝开销和提高效率，但自 C++11 起，语言引入了右值引用、移动语义与完美转发这三项关键特性，让资源管理与性能优化进入了新的阶段。
这些新特性解决了旧语法中“临时对象反复拷贝”“容器插入效率低”“泛型函数无法正确转发右值”等问题，使得对象资源能够安全地被移动、被复用、被完美传递。
本文将系统讲解：
- 左值与右值的本质区别；
- 右值引用的设计动机与语法规则；
- 移动语义在性能优化中的应用；
- 完美转发与
std::forward的工作机制。
通过配图、示例与实测分析，读者将从语法到底层彻底掌握这一组 C++11 的核心机制，为后续学习 STL 容器的现代实现、泛型编程与高性能系统代码打下坚实基础。
一、左值和右值
1. 左值
-
左值：是一个表示数据的表达式(如变量名或解引用的指针)，一般以持久状态存储在内存中。
- 左值一定可以取地址，一般可以赋值。
- 定义时被 const 修饰的左值，定义之后不能再给它赋值，但可以取它的地址。
-
总结左值 (lvalue)：有名字、可寻址、能持久存在的对象。
👉 可以出现在=的左边，也可以出现在=的右边
// a, b, c, d 都是左值
int a = 10;
int b = a;
const int c = 30; // 被 const 修饰的左值 依然是左值
const int* d = &c;// 以下的 p, q, x, *p 都是左值
int* p = new int(10);
int q = 1;
const int x = 2;// 以下也都是左值
"xxxxxx"; // 该表达式的含义是 该字符串首元素的地址
const char* px = "xxxxxx"; // 该表达式的含义是，把 "xxxxxx" 首元素的地址赋值给 px
p[2]; // 左值// 左值可以被取地址
cout << &("xxxxx") << endl; // 可以取地址， 左值
cout << &px[2] << endl; // 可以取地址， 左值
2. 右值
- 右值：也是一个表示数据的表达式，将亡值 为一种典型的右值。
- 常见右值举例：字面常量（10, 1.1），**函数的传值返回值(**不能是左值引用返回)，表达式求值过程中创建的临时对象，匿名对象等。
- 右值不能取地址，右值也不能修改
- 总结右值 (rvalue)：没有名字、不能持久存在的临时值。
👉 一般出现在=的右边，不能出现在=的左边- 内置类型的右值被称为纯右值
- 自定义类型的右值被称为将亡值
常见左值右值分类举例：
| 表达式 | 左值还是右值 | 说明 |
|---|---|---|
int a = 10; | a 是左值 | a 有名字，可寻址 |
10 | 右值 | 字面量常量，临时值 |
a + 1 | 右值 | 表达式结果是临时对象 |
a = 5 | 左值 | （注意！）赋值表达式的 结果本身 是左值 |
std::move(a) | 右值 | 强制把左值转换成右值 |
*p | 左值 | 解引用后得到可取地址的对象 |
a++ | 右值 | 后置自增返回的是旧值的拷贝（临时） |
++a | 左值 | 前置自增返回的是自身 |
返回右值的函数fmin
// 返回右值的函数
int fmin(int a, int b) {return a < b ? a : b;
}
void test2() {double x = 1.1, y = 2.2;// 以下三个表达式的返回值都是常见的右值10;x + y; // 表达式的返回值为右值fmin(x, y); // 这里的右值指的 是 函数返回值 中的 传值返回，返回的那个临时对象// 右值不能取地址/*cout << &10 << endl;cout << &(x + y) << endl;cout << &fmin(1, 2) << endl;*/
}
- 值得一提的是，左值的英文简写为
lvalue，右值的英文简写为rvalue。
- 传统认为它们分别是
left value、right value的缩写。- 现代C++中，
lvalue被解释为loactor value的缩写，可意为存储在内存中、有明确存储地址、可以取地址的对象rvalue被解释为read value，指的是那些可以提供数据值，但是不可以寻址的对象。
- 例如：临时变量，字面量常量，存储于寄存器中的变量等。
- 左值和右值的核心区别是能否取地址。
二、左值引用和右值引用
引用是给对象取别名
- 左值引用 : 给左值取别名
- 右值引用 : 给右值取别名
1. 左值引用 vs 右值引用
左值引用和右值引用的语法：
-
左值引用：
Type& -
右值引用：
Type&&
double x = 1.5, y = 2.5;// 左值引用: 给左值取别名
int a = 10;
int& r1 = a;// 返回右值的函数
double fmin(double a, double b) {return a < b ? a : b;
}// 右值引用: 给右值取别名
int&& r5 = 20;
//double& r6 = x + y; // 编译不通过 不能用左值引用给右值取别名double&& r6 = x + y; // X + y 返回的结果为右值 右值引用
double&& r7 = fmin(x, y) // 对fmin返回的右值 进行右值引用
2. const 左值引用给右值取别名
左值引用能否给右值取别名？
- 左值引用不能直接给右值取别名，
const左值引用 可以 给右值取别名
double x = 1.5, y = 2.5;// 普通左值引用: 给左值取别名
int a = 10;
int& r1 = a;// 左值引用能否给右值取别名？
// const 左值引用 可以 给右值取别名
const int& r2 = 20;
const double r3 = x + y;
3. 右值引用不能直接给左值取别名
右值引用能否给左值取别名？
- 右值引用不能直接给左值取别名，但可以给
std::move()后的左值取别名
// 普通右值引用: 给右值取别名
int&& r5 = 20;
double&& r6 = x + y; // X + y 返回的结果为右值 右值引用// 右值引用 可以给 std::move 后的左值取别名
//int&& r7 = a; // 编译报错, 右值引用不能直接给左值取别名
int&& r7 = std::move(a); // 可以给 std::move 后的左值取别名
4. std::move()的作用
std::move 是标准库的函数模板，定义简化如下：
template <class T>
typename remove_reference<T>::type&& move(T&& arg)
{// 强制类型转换：将 arg 转为右值引用返回return static_cast<typename remove_reference<T>::type&&> (arg);
}
std::move的本质是强制类型转换，返回左值的右值引用，std::move后的左值可以绑定到右值引用- 注意：
std::move本身不移动数据，只是 “允许右值引用绑定”，真正的移动语义由移动构造 / 移动赋值 函数实现
5. 总结
- 左值和右值的本质区别是：能否取地址
- 内置类型的右值被称为纯右值
- 自定义类型的右值被称为将亡值
- 左值引用 : 给左值取别名，左值引用可以直接给左值取别名
- const左值引用 可以 给右值取别名
- 右值引用 : 给右值取别名，右值引用可以直接给右值取别名
- 右值引用可以给
move后的左值取别名，不能直接给左值取别名
- 右值引用可以给
三、右值引用解决左值引用的缺陷
1. 左值引用的价值与缺陷
左值引用使用场景 ：
- 做输出型参数，减少大对象的拷贝
- 做返回值减少拷贝
价值: 减少拷贝
缺陷：局部对象做返回值时，不能用左值引用返回，此时必须传值返回。如以下场景：
string func() {std::string str;std::cin >> str;// ... 一系列操作return str;
}
-
以上函数传值返回，在没有右值引用时，需要拷贝资源，存在拷贝资源的性能开销
-
局部
string返回string&时存在的两层问题：
- 左值引用无法解决以上问题，该场景只能传值返回，性能开销较大
右值引用发明之前，以上场景只能传值返回
2. 传值返回时编译器RVO的优化
string Func1()
{string str;cin >> str;// ...return str;
}
void test4()
{ string ret1 = Func1();
}
- 以上场景编译器不进行优化时，会发生两次深拷贝，每次深拷贝都伴随着以下三个步骤：
-
开空间
-
深拷贝数据
-
调用析构函数释放原来空间
-
以上操作叠加起来，时间代价极大
因此以上步骤被编译器优化为了一次拷贝构造：同一个执行步骤中，进行连续的构造或拷贝构造，编译器会优化成一次直接构造.
- 优化：在
str销毁前，直接用str拷贝构造ret1，优化为一次拷贝构造
如下为有无优化的详解过程：
如果没有优化（没有 RVO/NRVO / copy elision）：
- 局部
str→ （深拷贝）→ 形成临时返回值对象 - 临时返回值对象 → （深拷贝）→
ret1
➡️一共可能有 两次构造开销（两次深拷贝构造 + 两次析构）。
如果有优化（现代编译器默认开启）
-
C++17 标准规定：强制性返回值优化（RVO），即使返回值不加
std::move，str也会被直接构造在调用者ret1的存储空间上。 -
所以优化后直接使用局部str构造ret对象，只有 一次直接构造，没有临时对象。
✅ 结论：
- 不做优化（老编译器/关闭优化）：会深拷贝生成一个临时对象，再调用一次深拷贝构造
ret1。 - C++17 及之后标准 / 常见编译器优化开启时：直接在
ret1上构造，不会有临时对象，减少了深拷贝消耗。
3. 无法优化的场景
以下场景无法被优化，会发生两次拷贝构造。
无法优化的原因是：同一个执行步骤中，没有发生连续的构造或拷贝构造，编译器无法优化
string Func1() {string str;cin >> str;// ...return str;
}void test4() {string ret1;// ... 一系列操作ret1 = Func1();
}
- 因为
ret1 = Func1()不是连续的构造，也不是连续的拷贝构造，此处编译器无法优化。在没有右值引用的移动语义时，存在两次深拷贝的性能开销
4. 左值和右值的参数匹配
-
C++98中，函数参数为 const 左值引用 时，传实参时，左值和右值都可以匹配 -
C++11以后，分别实现参数为 左值引用、const 左值引用、右值引用的函数，构成函数重载- 实参传入左值：匹配左值引用，
- 实参传入 const 左值：匹配 const 左值引用
- 实参传入右值：匹配右值引用
-
以下
func1函数构成函数重载：分别传入左值、const 左值、右值时，会==调用参数最匹配的函数==
// 以下三个函数构成函数重载
void func1(int& r) {cout << "void func1(int& r)" << endl;
}
void func1(const int& r) {cout << "void func1(const int& r)" << endl;
}
void func1(int&& r2) {cout << "void func1(int&& r)" << endl;
}
void test5() {int a = 0;const int b = 20;func1(a); // 这里两个func1都可以调用，但这里不会出现歧义，编译器会去调用最匹配的那个函数func1(b);func1(a + b); // a + b 是右值，右值引用版本 最匹配，因此调用右值引用版本
}
四、右值引用的移动语义
右值有以下分类：
-
内置类型的右值：认为是纯右值
-
自定义类型的右值：认为是将亡值
实现了简单移动赋值和移动拷贝构造的m_string类：
// m_string.h// 移动拷贝构造
string(string&& str) {cout << "string(string&& str) -- 移动拷贝构造" << endl;swap(str);
}// 移动赋值
string& operator=(string&& str) {cout << "string& operator=(string&& str) -- 移动赋值" << endl;swap(str);return *this;
}
- 移动构造：把另一个右值将亡值对象的资源直接“偷”过来（交换指针），避免深拷贝。
- 移动赋值：把已有对象的资源释放，然后再接管右值将亡值对象的资源。
上述
string类中移动赋值和移动构造的实现不够规范，移动赋值和移动构造函数不应抛异常，应给函数标上noexcept
1. 移动赋值
认识移动赋值
移动赋值运算符（Move Assignment Operator ）：是实现移动语义的一个核心工具。
移动赋值运算符的核心：用于将一个临时对象（右值）的资源“窃取”并赋值给一个已存在的对象，而非进行耗时的深拷贝赋值，从而优化性能。
class MyClass
{
private://1.动态分配的资源（如：数组、缓冲区等）//2.资源大小（如：数组长度）int* data; size_t size; public:/*------------------------------移动赋值运算符的定义格式------------------------------*///移动赋值运算符：通过右值引用接收临时对象，实现资源的高效转移 MyClass& operator=(MyClass&& other) noexcept //noexcept关键字声明：承诺不会抛出异常（移动操作应避免抛异常，否则可能导致资源泄漏）{//1.自赋值检查：避免自己给自己赋值（如：a = std::move(a)）if (this != &other) //注意：若不检查，delete[] data 会释放自己的资源，后续又从自己窃取资源，导致悬空指针{//2.释放当前对象的旧资源：防止内存泄漏delete[] data; //例如：当前对象持有动态分配的数组，需先释放//3.从other中“窃取”资源 + 置空原对象指针data = other.data; // 接管指针（如：动态数组、文件句柄等）other.data = nullptr; // 置空原对象指针：防止原对象析构时重复释放资源//4.复制资源元数据 + 重置原对象状态size = other.size;other.size = 0; //确保原对象析构时不会影响已转移的资源//注意：原对象仍需保持可析构状态（如：调用默认析构函数不会崩溃）}//5.返回当前对象引用return *this; //支持链式赋值（如 a = b = c）}
};移动赋值运算符的核心逻辑：
-
参数类型：移动赋值运算符同样接收一个右值引用参数
-
自我赋值检查：
if (this != &other)避免自己赋值给自己时出错 -
释放旧资源：先删除当前对象的资源（
delete[] data），避免内存泄漏 -
资源转移：同移动构造函数，接管原对象的资源并重置原对象
有RVO时的移动赋值
m_string::string test6() {m_string::string str("xxxxxxxxxxxxxxxxxxx");// ...return str;
}
void test7() {m_string::string ret2;// ...ret2 = test6();
}
调用分析：
调用 test6()：ret2 接收test6的返回值
-
如果编译器开启返回值优化 (RVO / NRVO)
- 会用
str直接在ret2的存储区构造一个右值m_string::string对象，不会发生拷贝/移动，不调用移动构造，仅发生一次直接构造。
- 会用
-
如果编译器禁用返回值优化 (关闭 -fno-elide-constructors)，且实现了 string 的移动构造
-
由于
str是局部变量，返回时会被视为右值将亡值，会先用str调用移动构造生成临时对象，临时对象再作为右值返回给ret2，之后调用移动赋值。 -
ret2 = test6();：test6()返回的临时对象是 右值，因此调用的是 移动赋值运算符： -
string& operator=(string&& str); -
在移动赋值中，
swap(str)把ret2的资源和右值对象的资源交换，ret2就拥有了右值对象的内容。 -
最后：临时右值对象（
test6()的返回值）生命周期结束，被析构，但它已经被swap交换成空壳，所以析构代价极小。
-
移动赋值/移动构造窃取资源时的调用流程：
无RVO时的移动赋值
m_string::string test6() {m_string::string str("xxxxxxxxxxxxxxxxxxx");// ...return std::move(str);
}
void test7() {m_string::string ret2;// ...ret2 = test6();
}
调用过程分析：
禁用编译器的 RVO 优化后，以上过程分为两步完成：
- 由于
str为右值将亡值，调用移动拷贝构造，构造出一个临时对象 - 临时对象为右值将亡值，调用移动赋值，赋值给ret2
2. 移动构造
认识移动构造
移动构造函数（Move Constructor）：是一种特殊的构造函数，用于实现“移动语义"。
移动构造函数的核心：将一个临时对象（右值）的资源“窃取”过来为己所用，而不是进行耗时的深拷贝，从而提高程序性能。
- 尤其适用于管理动态内存、文件句柄等资源的对象
class MyClass
{
private://1.动态分配的资源（如：数组、缓冲区等）//2.资源大小（如：数组长度）int* data; size_t size; public:/*------------------------------移动构造函数的定义格式------------------------------*///移动构造函数：通过右值引用接收临时对象，实现资源的高效转移MyClass(MyClass&& other) noexcept //noexcept关键字声明：承诺不会抛出异常（移动操作应避免抛异常，否则可能导致资源泄漏）{// 核心逻辑：将临时对象（右值）的资源所有权转移到当前对象，而非复制资源/*--------------第一步：接管资源--------------*/data = other.data; //直接获取原对象的指针（无需分配新内存，避免深拷贝）/*--------------第二步：置空原对象指针--------------*/other.data = nullptr; //防止原对象析构时释放已转移的资源（必须操作）//注意：这一步使原对象进入“有效但可析构”的状态（通常称为“被移动状态”）/*--------------第三步：复制资源元数据--------------*/size = other.size; //例如：大小信息/*--------------第四步：重置原对象状态--------------*/other.size = 0; //确保原对象析构时不会影响已转移的资源//注意：原对象仍需保持可析构状态（如：调用默认析构函数不会崩溃）}
};
移动构造函数的核心逻辑：
- 参数类型：必须是右值引用例如
MyString&&，确保只接收右值(临时对象) - 资源转移：直接拷贝原对象的资源指针（
data=other.data），而非重新分配内存 - 重置原对象：将原对象的指针置空（
other.data = nullptr），避免析构时双重释放资源 noexcept关键字：声明函数不会抛出异常，使容器（如：vector）在扩容时优先选择移动而非拷贝（提升性能)
编译器不做优化时的移动构造
m_string::string test6() {m_string::string str("xxxxxxxxxxxxxxxxxxx");// ...return str;
}
void test7() {m_string::string ret1 = test6(); // 连续的拷贝和构造 优化为直接构造
}
编译器优化后的移动构造
m_string::string test6() {m_string::string str("xxxxxxxxxxxxxxxxxxx");// ...return std::move(str);
}
void test7() {m_string::string ret1 = test6(); // 连续的拷贝和构造 优化为直接构造
}
五、右值引用和移动语义的应用场景
编译器做的优化：
- 把传值返回的需要深拷贝自定义类型，强行识别成右值。
- 这样就可以调用移动构造和移动赋值，窃取资源，避免拷贝
1. 自定义类型中深拷贝的类，必须传值返回的场景
std::move的意义就在于，可以让一个对象的资源可以被抢走。
右值引用配合移动语义，可以极大地提高性能，减少深拷贝
代码片段
m_string::string test6() {m_string::string str("xxxxxxxxxxxxxxxxxxx");// ...return std::move(str);
}m_string::string ret1 = test6(); // 移动拷贝m_string::string ret3("1111111111111111111111");
m_string::string copy1 = ret3; // 深拷贝move(ret3);
m_string::string copy2 = ret3; // 深拷贝m_string::string copy3 = move(ret3); // 移动拷贝
运行结果分析
移动语义的核心：资源抢占
当我们写：
m_string::string copy3 = std::move(ret3); // 移动拷贝
这时发生的事情是：
std::move(ret3)把ret3转为右值引用；- 编译器匹配到移动构造函数（形如
string(string&& s)）； - 在移动构造函数中，
copy3不会重新分配内存，而是直接“接管”ret3的资源指针； - 同时将
ret3的内部指针置为nullptr，防止重复释放。
这种资源“抢占”让构造过程几乎为 O(1)，极大地减少了内存开销。
2. STL 容器的插入接口
STL 容器的插入接口，如果插入对象是右值，可以利用移动构造或移动赋值转移资源给数据结构中的对象，减少深拷贝
如以下代码场景：
std::list<m_string::string> lt;
m_string::string s1("111111111111111111111");
lt.push_back(s1);cout << endl;m_string::string s2("111111111111111111111");
lt.push_back(move(s2));cout << endl;lt.push_back("22222222222222222222222222");
C++98中的调用过程
C++11中的配合move产生右值
右值的日常写法
- 日常写法一般不会先构造出一个左值，再对左值加
std::move，而是会直接构造一个匿名对象，匿名对象为右值
深拷贝和移动拷贝的对比
六、引用折叠与万能引用
1. 引用折叠
引用折叠：是 C++11 引入的一个重要特性，它和模板、右值引用等概念紧密相关，在一些复杂的类型推导场景中发挥着关键作用。
在 C++ 中：
- 直接定义 “引用的引用” ，比如：
int& && r = i;（i是一个int类型变量）是不被允许的，会直接导致编译报错 - 但在模板实例化或使用
typedef进行类型操作时，可能会出现多个引用叠加的情况，这时候就需要引用折叠规则来确定最终的引用类型
简单来说：引用折叠就是在特定情况下，将多个连续的引用类型 “折叠” 成一个引用类型
当通过 模板/typedef 构造出 “引用的引用” 时，C++11 用引用折叠规则统一处理：
T& &→T&(左值引用的左值引用 —> 折叠为 —> 左值引用)
T& &&→T&(右值引用的左值引用 —> 折叠为 —> 左值引用)
T&& &→T&(左值引用的右值引用 —> 折叠为 —> 左值引用)
T&& &&→T&&(右值引用的右值引用 —> 折叠为 —> 右值引用)
引用折叠规则总结：
- 右值引用的右值引用折叠成右值引用
- 其他组合均折叠成左值引用
2. 模板的万能引用
模板中的 && 不代表右值引用，而是万能引用，其既能接收左值又能接收右值。
template <typename T>
void func(T&& t)
{ /* ... */
}
这里的 T&& t 看起来是 “右值引用参数”，但结合引用折叠规则后，它会根据传入实参的类型 “自适应”：
由引用折叠规则可知：
- 传入左值时：
T会被推导为 左值引用类型，即T = int&。于是T&&展开为int& &&，按引用折叠规则变为int&。因此t的类型为 左值引用。 - 传入右值时：
T会被推导为 非引用类型，即T = int，所以T&&为int&&，即 右值引用。
这种能同时适配左值、右值的模板参数，也被称为万能引用（或 “转发引用”）—— 靠模板推导把 T 变成 t&（左值）或 t（右值）。
总结：当模板函数中出现T&&时：
- 实参是左值：
t的类型就是左值引用 - 实参是右值：
t的类型就是右值引用
万能引用的例子：
//万能引用
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)Function(a); // 左值// std::move(a)是右值，推导出T为int，模板实例化为void Function(int&& t)Function(std::move(a)); // 右值const int b = 8;// b是左值，推导出T为const int&，引用折叠，模板实例化为void Function(const int& t)Function(b); // const 左值 所以Function内部 进行 x++ 操作时, 会编译报错// std::move(b)右值，推导出T为const int，模板实例化为void Function(const int&& t)Function(std::move(b)); // const 右值 所以Function内部 进行 x++ 操作时, 会编译报错return 0;
}
综上，万能引用在接受左值和右值时：
- 被传左值就实例化左值引用版本
- 被传右值就实例化右值引用版本
这就是模板的万能引用
七、完美转发及其应用
1. 左值引用和右值引用本身均是左值
右值引用类型的变量在用于表达式时，属性是左值。原因是**在移动构造的场景下，右值引用必须要支持修改，否则无法完成资源转移**
这个设计这里会感觉很怪，等我们讲右值引用及完美转发的使用场景时，就能体会这样设计的价值了
右值的两个本质特征：
- 右值不能取地址
- 右值不能修改
右值引用本身也是一个变量，这个变量本身的属性是左值，如下代码验证了这个结论：
int a = 19;
int& r = a;
int&& rr = std::move(a);cout << &r << endl;
cout << &rr << endl;
由上可知：
-
左值引用类型的变量
r，可以取地址，可以修改，因此左值引用类型的变量的属性是左值 -
右值引用类型的变量
rr，可以取地址，可以修改，因此右值引用类型的变量的属性是左值
总结：
左值引用和右值引用本身均是左值
-
左值引用，引用的对象为左值，左值引用类型的变量，本身是左值
-
右值引用，引用的对象为右值，但右值引用类型的变量，本身是左值
2. 完美转发及其应用
什么是完美转发？
完美转发：是 C++11 及以后引入的一项重要特性，它允许函数模板将其参数原封不动地转发给另一个函数，保持参数的 原始值类别（左值或右值）和 常量性
- 完美转发主要借助 引用折叠 和
std::forward实现，用于在函数模板中精准保留参数的 “左值/右值属性”，并将其原封不动地转发给下一层函数
为什么需要完美转发？
右值引用的“左值属性”问题：
- 结合变量表达式的规则 (所有变量表达式都是左值)
- 即使右值被右值引用（T&&）绑定，右值引用变量本身仍属于左值（可被取地址、赋值等）
这会导致一个问题：
- 在
PerfectForward函数内部，若把t传递给下一层函数Func，t会被当作左值处理，只能匹配Func的左值引用版本 - 但我们希望保留t原始的“左值/右值属性”（比如：让右值继续匹配Fun的右值引用版本），这时就需要 完美转发 来解决
示例问题（无完美转发时）
#include <iostream>
using namespace std;void Func(int& x) { cout << "左值引用版本\n"; }
void Func(int&& x) { cout << "右值引用版本\n"; }template<typename T>
void PerfectForward(T&& t)
{Func(t); //t 是右值引用变量，但本身是左值 → 调用 Fun(int&)
}int main()
{PerfectForward(10); //传递右值下去，期望调用 Fun(int&&)，实际调用 Fun(int&)return 0;
}
如何实现完美转发？
完美转发通过 std::forward 函数模板实现，核心依赖 引用折叠 和 模板参数推导
std::forward 的简化原理：
std::forward利 用 引用折叠 和 模板参数 推导，“还原”参数原始的左值/右值属性
// std::forward函数模板的关键逻辑可简化实现为：template <typename T>
T&& forward(typename remove_reference<T>::type& arg)
{return static_cast<T&&>(arg); // 强制类型转换，触发引用折叠
}
完美转发的流程：
以 PerfectForward(10) 为例，完整流程:
- 模板参数推导：传入右值 10 →
PerfectForward的T推导为int（非引用类型），形参t是int&&（右值引用） - 调用
std::forward：在PerfectForward中调用Func(std::forward<T>(t)） →T是int类型，std::forward<int>(t)会:- 通过
static_cast<int&&>(t)将t强转为int&&(右值引用） - 触发
Func(int&&)重载，实现保留右值属性
- 通过
完美转发保持对象的原生属性
- 将
Fun(t)调用修改为Fun(forward<T> (t))：即可利用完美转发保持所引用对象的左值属性或右值属性
#include <iostream>
using namespace std;void Func(int& x) { cout << "左值引用版本\n"; }
void Func(int&& x) { cout << "右值引用版本\n"; }template<typename T>
void PerfectForward(T&& t)
{//Func(t); //t 是右值引用变量，但本身是左值 → 调用 Fun(int&)Func(std::forward<T> (t)); //t 是右值引用变量，本身是左值，利用完美转发保持右值属性，调用 Func(int&& x)
}int main()
{PerfectForward(10); //传递右值下去，利用完美转发保持所引用的右值对象的右值属性，调用 Func(int&& x)return 0;
}
总结完美转发的使用：
template<typename T>
void PerfectForward(T&& t)
{//Fun(t);// 完美转发保持对象的原生属性// 完美转发: 引用折叠后 t 是左值引用，完美转发后，t保持左值属性// 完美转发: 引用折叠后 t 是右值引用，完美转发后，t保持右值属性Fun(forward<T> (t));
}
3. 完美转发的应用场景
- 标准库中的
list可以调用移动构造 - 我们自己实现的
list无法调用我们的string实现的移动构造
- 构造
lt的时候，构造了哨兵位的头结点，因此string一共是四次构造函数 - 之前
list实现的push_back和insert，参数类型为 const引用，左值和右值都会调用const左值引用版本的push_back和insert
void push_back(const T& val)
{insert(end(), val);
}
iterator insert(iterator pos, const T& val)
{Node* newNode = new Node(val);newNode->_next = pos._node;newNode->_prev = pos._node->_prev;pos._node->_prev->_next = newNode;pos._node->_prev = newNode;++_size;return iterator(newNode); // 返回新插入元素的位置
}
补充实现右值引用版本的push_back和insert，增加和修改以下函数
void push_back(T&& val) {insert(end(), std::forward<T> (val));
}
iterator insert(iterator pos, T&& val)
{Node* newNode = new Node(std::forward<T> (val));newNode->_next = pos._node;newNode->_prev = pos._node->_prev;pos._node->_prev->_next = newNode;pos._node->_prev = newNode;++_size;return iterator(newNode); // 返回新插入元素的位置
}// 结点创建时的构造函数
list_node(const T& val):_next(nullptr), _prev(nullptr), _val(val)
{ }list_node(T&& val):_next(nullptr), _prev(nullptr), _val(std::forward<T> (val))
{}// 由于node的构造函数去掉了默认参数，因此此处传入一个匿名对象
void empty_init() {_head = new Node(T()); // 匿名对象为右值，构造 Node 时会匹配右值版本的构造函数_head->_next = _head;_head->_prev = _head;_size = 0;
}
需要注意的是：
- 我们期望调用右值引用版本的
push_back，而push_back是借助insert实现的，push_back函数中将待插入的值传递到了insert函数中去。而右值引用变量本身是左值，如果想调用右值引用版本的insert函数，需要在push_back向insert传参时使用完美转发，保持对象的右值属性，才能匹配到右值引用版本的insert函数 insert中，右值引用val被向下传递给了Node的构造函数，我们期望调用右值引用版本的Node构造函数，因此同样需要使用完美转发向下传递参数Node的构造函数对val使用初始化列表初始化成员变量_val，会调用_val类型的默认构造进行初始化，为了确保能够调用右值引用版本的移动构造，传参时需要使用完美转发保持val对象的右值属性
修改后结果如下：
八、std::move VS std::forward
1. 右值引用 对比 万能引用
| 对比项 | 右值引用（Rvalue Reference） | 万能引用（Forwarding Reference） |
|---|---|---|
| 语法形式 | Type&&（类型已确定） | T&&（其中 T 是模板参数并可推导） |
| 是否依赖类型推导 | ❌ 否 | ✅ 是 |
| 是否发生引用折叠 | ❌ 否 | ✅ 会发生（T& && → T&，T&& && → T&&） |
| 能绑定的实参类型 | 仅能绑定右值 | 既能绑定左值也能绑定右值 |
| 典型使用场景 | 移动构造函数、移动赋值、接收右值对象 | 泛型模板函数、完美转发 |
| 函数形参的值类别 | 始终是右值引用，但在函数体内是左值 | 随实参推导：左值 → 左值引用；右值 → 右值引用 |
| 在函数内部的传递方式 | 使用 std::move(param) 强制右值化 | 使用 std::forward<T>(param) 保持实参的值类别 |
| 语义目标 | 启用移动语义（资源转移） | 实现完美转发（不改变值类别） |
| 传递结果 | 始终右值 | 与实参值类别一致 |
| 风险 | 被移动对象不可再安全使用 | 无资源转移风险，仅保持原值类别 |
| 常见示例 | 移动构造函数、容器的移动插入 | emplace_back、push_back 等模板接口 |
2. std::move 与 std::forward 的使用场景总结：
std::forward：
当形参类型是万能引用（T&&，其中 T 是模板参数并**可推导），在函数内部将该形参传递给其他函数时，应使用
std::forward<T>(param) 来保持实参的值类别（左/右值）**。
换句话说，完美转发的意义在于“不改变传入对象的左/右值属性”。
std::move：
当形参类型是普通右值引用（Type&&，其中 Type 是**已确定类型、不可推导）时，在函数内部将该形参传递给其他函数时，应使用
std::move(param) 将其显式转换为右值，从而触发移动语义**。
换句话说，
std::move的意义在于：“告诉编译器：此对象的资源可以被转移，不再需要保持原值。”
结语
右值引用、移动语义与完美转发的出现，标志着 C++ 从“拷贝一切”的传统模型迈向了“高效资源转移”的新时代。
它们不仅优化了对象的构造与赋值过程，更让泛型代码在类型推导与参数传递中保持了语义一致性与性能最优。
理解这些概念后，我们在写代码时：
- 知道何时该深拷贝，何时该移动；
- 明白模板函数如何无损转发参数；
- 能在 STL 与自定义容器中正确利用移动构造与完美转发。
这不仅是一场语法的革新，更是 C++ 性能哲学的进化。
让我们带着对效率与优雅的追求，继续探索现代 C++ 的更多可能。
以上就是本文的所有内容了，如果觉得文章对你有帮助，欢迎 点赞⭐收藏 支持！如有疑问或建议，请在评论区留言交流，我们一起进步
分享到此结束啦
一键三连，好运连连！你的每一次互动，都是对作者最大的鼓励！
征程尚未结束，让我们在广阔的世界里继续前行！🚀