C++11——右值引用&完美转发

总而言之，右值引用，完美转发，std::move()都是为了在程序运行过程中，避免变量多次重复的申请和释放内存空间，使用移动语义将申请的空间通过这几种方式进行循环使用，避免重新开辟新空间和拷贝浪费算力。

右值引用

一、什么是右值引用？

在 C++ 中：

• 左值（Lvalue）：有名字、有地址、可以被引用（如变量 x）
• 右值（Rvalue）：临时对象、没有名字、无法被再次引用（如字面值 5，表达式 x + y）

语法：

int&& r = 10; // r 是一个右值引用 

右值引用使用 && 定义。

---

二、为什么需要右值引用？

传统的 C++（C++03）只有拷贝语义，会频繁复制对象，性能开销大。

右值引用的目的：

• 避免不必要的拷贝
• 支持移动语义

---

三、右值引用与移动构造函数

来看一个例子：

#include <iostream> #include <vector> using namespace std;  class Buffer { public:     int* data;     size_t size;      Buffer(size_t s) : size(s) {         data = new int[s];         cout << "Constructor" << endl;     }      ~Buffer() {         delete[] data;         cout << "Destructor" << endl;     }      // 拷贝构造函数     Buffer(const Buffer& other) : size(other.size) {         data = new int[size];         std::copy(other.data, other.data + size, data);         cout << "Copy Constructor" << endl;     }      // 移动构造函数     Buffer(Buffer&& other) noexcept : data(other.data), size(other.size) {         other.data = nullptr; // 接管资源         other.size = 0;         cout << "Move Constructor" << endl;     } };  int main() {     Buffer b1(100);     Buffer b2 = std::move(b1); // 调用移动构造函数 } 

输出：

Constructor Move Constructor Destructor 

👉 这里的 std::move 是 把左值转换成右值引用，以启用移动语义。

---

四、移动 vs 拷贝 的区别

• 拷贝构造函数：复制数据（深拷贝），两份资源。
• 移动构造函数：窃取资源指针，避免分配内存，效率更高。

---

五、右值引用的常见用法

✅ 1. 移动构造 / 移动赋值

Buffer(Buffer&& other);              // 移动构造 Buffer& operator=(Buffer&& other);  // 移动赋值 

✅ 2. std::move 转换左值为右值引用

Buffer a(10); Buffer b = std::move(a); // a 不再使用，资源移动给 b 

✅ 3. 完美转发（在模板中）

template <typename T> void wrapper(T&& arg) {     process(std::forward<T>(arg)); // 保留左/右值特性 } 

---

六、右值引用 vs const 引用

特性	const T&	T&&（右值引用）
是否可修改	否	可以（除非你加 const）
是否绑定右值	✅ 可以	✅ 可以，仅右值
是否绑定左值	✅ 可以	❌ 不行
是否触发移动构造	❌ 不会	✅ 会

---

七、小结：右值引用是为“临时对象优化而生”

• 节省资源分配与拷贝成本（性能提升显著）
• 和 std::move、std::forward 配合使用
• 支持自定义类的资源管理（RAII）更高效

---

完美转发

一、什么是完美转发？

完美转发的目标是：在模板中接收到参数后，不改变它的值类别（左值/右值）传递给其他函数。

---

🧠 举个问题：

你写了一个模板函数，想把参数“原封不动”地传给另一个函数，但：

void func(int& x) { cout << "Lvalue" << endl; } void func(int&& x) { cout << "Rvalue" << endl; }  template<typename T> void wrapper(T t) {     func(t); // 始终是左值，即使调用时是右值！ }  int main() {     int a = 5;     wrapper(a);        // Lvalue     wrapper(10);       // ❌ 还是 Lvalue } 

问题在于：模板参数 t 是一个左值变量，哪怕传进来的是右值，也会退化为左值。

---

二、解决方案：std::forward<T>(t)

template<typename T> void wrapper(T&& t) {     func(std::forward<T>(t)); // 保留原始类型特性 } 

⚠️ 注意：

• T&& t 是 万能引用（Universal Reference），也叫转发引用（Forwarding Reference）
• std::forward<T>(t) 是 完美转发 的关键，作用是：如果传进来是右值，就转发为右值；否则为左值

---

三、标准库中的使用案例：emplace_back

std::vector<std::string> vec; vec.push_back("hello");           // 拷贝构造或移动构造 vec.emplace_back("hello");       // 直接构造在容器内部 

emplace_back 原理（简化）：

template<typename... Args> void emplace_back(Args&&... args) {     // Args... 是参数类型包     // Args&&... 是万能引用     construct(std::forward<Args>(args)...); // 完美转发给构造函数 } 

➡️ 这样就可以避免临时对象的生成，直接在容器内部原地构造，提高效率！

---

四、小结：完美转发的关键词

概念	说明
T&& 在模板中	是万能引用（不是右值引用）
std::forward<T>(x)	保持 x 原来的值类别（左值/右值）
使用场景	构造函数转发、函数封装、容器的 emplace 系列等

---

五、一个完整的例子（构造任意类型）

#include <iostream> #include <utility>  using namespace std;  class MyClass { public:     MyClass(int x) { cout << "int ctor" << endl; }     MyClass(const MyClass& other) { cout << "copy ctor" << endl; }     MyClass(MyClass&& other) noexcept { cout << "move ctor" << endl; } };  template<typename T, typename... Args> T* create(Args&&... args) {     return new T(std::forward<Args>(args)...); // 完美转发构造对象 }  int main() {     MyClass* a = create<MyClass>(10);     // 调用 int 构造函数     MyClass b;     MyClass* c = create<MyClass>(b);      // 调用 copy ctor     MyClass* d = create<MyClass>(std::move(b)); // move ctor } 

---

std::move

🧠 一句话：

std::move() 是现代 C++ 中处理 右值引用、移动语义 的关键工具。std::move(obj) 并不会“移动”对象，而是把 obj 强制转换为右值引用，以便触发移动构造/移动赋值。是一个 类型转换工具函数。

---

一、std::move() 的作用

C++ 中，只有右值可以绑定到右值引用 T&&。但是我们常常有一个左值变量，我们想“偷”它的资源（如在容器中或返回对象时）。这就需要：

std::move(x); // 把 x 转成右值，让移动构造函数或移动赋值被调用 

---

二、std::move() 的常见用法

✅ 1. 移动构造 / 赋值

Buffer b1; Buffer b2 = std::move(b1); // 触发移动构造函数 

✅ 2. 函数返回值优化

Buffer generateBuffer() {     Buffer temp;     return std::move(temp); // 可选，现代编译器可自动优化（NRVO） } 

✅ 3. 容器中移动元素

std::vector<std::string> vec; std::string str = "hello";  vec.push_back(std::move(str)); // 移动 str，避免拷贝 

---

三、底层实现（源码原理）

// 位于 <utility> template<typename T> typename std::remove_reference<T>::type&& move(T&& t) noexcept {     return static_cast<typename std::remove_reference<T>::type&&>(t); } 

解读：

1. T&& t 是万能引用（可能是左值也可能是右值）
2. remove_reference<T>::type 去掉引用修饰
3. 最终执行一个 static_cast<T&&> —— 把值转换为右值引用类型

🔁 所以本质是：一个显式类型转换成右值引用的封装。

---

四、使用 std::move() 的注意事项 ⚠️

场景	是否应该用 std::move？	原因
变量将来还会使用	❌ 不推荐	被移动的对象通常处于“空壳”状态，后续使用容易出错
返回局部变量	✅ 可选	编译器可能已自动优化，但加 move 明确意图
函数参数是右值引用（T&&）变量	✅ 推荐	因为它是左值变量，仍需显式转换为右值
const 对象	❌ 无意义	const 对象不能移动，只能拷贝（移动构造需要非 const）

---

五、例子：const 对象不能用 move

const std::string s = "hello"; std::string t = std::move(s); // ❌ 实际是拷贝，因为 s 是 const，不能 move 

---

六、配套使用：std::move vs std::forward

工具	用于哪里	行为
std::move(obj)	强制为右值	总是把 obj 转换成右值引用（T&&）
std::forward<T>(obj)	完美转发（模板中）	保留 obj 的左/右值本性（用于泛型转发）

---

七、小结

✅ std::move() 本质是 static_cast<T&&>
✅ 用来启用移动语义，而不是实际移动
✅ 被移动的对象不能再继续用
✅ 与移动构造函数、移动赋值配合使用

---