右值引用与移动语义基础
面试考点
右值引用和移动语义是 C++11 最重要的特性之一。面试官通过这道题考察你对值类别的理解、移动构造/赋值的实现,以及移动语义带来的性能优化原理。
核心概念
左值(lvalue)有持久身份,可以取地址。右值(rvalue)是临时的、即将销毁的值。右值引用(T&&)可以绑定到右值,让我们"偷走"临时对象的资源而不是复制它们,这就是移动语义。
值类别
表达式
/ \
glvalue rvalue
/ \ / \
lvalue xvalue prvalue| 值类别 | 含义 | 示例 |
|---|---|---|
| lvalue | 有身份,可取地址 | 变量名、*ptr、arr[0] |
| prvalue | 纯右值,临时值 | 字面量 42、x + y、函数返回值(非引用) |
| xvalue | 将亡值,资源可被移走 | std::move(x)、返回 T&& 的函数 |
基本示例
cpp
#include <iostream>
#include <string>
#include <vector>
#include <utility>
// ============================
// 示例1:左值和右值
// ============================
void value_category_demo() {
int x = 10; // x 是左值
// int& ref = 42; // 错误:非 const 左值引用不能绑定到右值
int&& rref = 42; // OK:右值引用绑定到右值
rref = 100; // 可以修改(右值引用本身是左值)
const int& cref = 42; // OK:const 左值引用可以绑定到右值
std::cout << "rref = " << rref << std::endl;
// 重要:右值引用变量本身是左值!
// 因为它有名字、有地址
int&& a = 10;
// int&& b = a; // 错误!a 是左值(虽然类型是 int&&)
int&& b = std::move(a); // OK:std::move 把左值转为右值
}
// ============================
// 示例2:移动构造函数和移动赋值
// ============================
class MyString {
char* data_;
size_t size_;
void cleanup() {
delete[] data_;
data_ = nullptr;
size_ = 0;
}
public:
// 构造函数
MyString(const char* str = "") {
size_ = std::strlen(str);
data_ = new char[size_ + 1];
std::memcpy(data_, str, size_ + 1);
std::cout << "构造: \"" << data_ << "\"" << std::endl;
}
// 拷贝构造函数(深拷贝,代价高)
MyString(const MyString& other) {
size_ = other.size_;
data_ = new char[size_ + 1];
std::memcpy(data_, other.data_, size_ + 1);
std::cout << "拷贝构造: \"" << data_ << "\"" << std::endl;
}
// 移动构造函数(转移资源,代价低)
MyString(MyString&& other) noexcept {
// 偷走 other 的资源
data_ = other.data_;
size_ = other.size_;
// 让 other 处于有效但空的状态
other.data_ = nullptr;
other.size_ = 0;
std::cout << "移动构造: \"" << data_ << "\"" << std::endl;
}
// 拷贝赋值
MyString& operator=(const MyString& other) {
if (this != &other) {
cleanup();
size_ = other.size_;
data_ = new char[size_ + 1];
std::memcpy(data_, other.data_, size_ + 1);
std::cout << "拷贝赋值: \"" << data_ << "\"" << std::endl;
}
return *this;
}
// 移动赋值
MyString& operator=(MyString&& other) noexcept {
if (this != &other) {
cleanup();
data_ = other.data_;
size_ = other.size_;
other.data_ = nullptr;
other.size_ = 0;
std::cout << "移动赋值: \"" << data_ << "\"" << std::endl;
}
return *this;
}
~MyString() {
if (data_) {
std::cout << "析构: \"" << data_ << "\"" << std::endl;
}
delete[] data_;
}
void print() const {
std::cout << (data_ ? data_ : "(空)") << std::endl;
}
};
MyString make_string() {
MyString s("临时对象");
return s; // 返回值优化(RVO)或移动
}
void move_demo() {
std::cout << "--- 拷贝 ---" << std::endl;
MyString s1("Hello");
MyString s2 = s1; // 拷贝构造
std::cout << "\n--- 移动 ---" << std::endl;
MyString s3 = std::move(s1); // 移动构造
s1.print(); // s1 已被移空
std::cout << "\n--- 函数返回 ---" << std::endl;
MyString s4 = make_string(); // 可能 RVO 或移动构造
}
// ============================
// 示例3:标准库中的移动语义
// ============================
void stl_move_demo() {
std::string str = "Hello World";
std::cout << "移动前: str = \"" << str << "\"" << std::endl;
std::string str2 = std::move(str);
std::cout << "移动后: str = \"" << str << "\"" << std::endl; // 可能为空
std::cout << "str2 = \"" << str2 << "\"" << std::endl;
// vector 的 push_back 有右值引用重载
std::vector<std::string> vec;
std::string s = "Test";
vec.push_back(s); // 拷贝
vec.push_back(std::move(s)); // 移动
vec.push_back("Temporary"); // 移动(字面量构造临时对象)
std::cout << "s 移动后 = \"" << s << "\"" << std::endl;
}
// ============================
// 示例4:移动后的对象状态
// ============================
void moved_from_state() {
std::vector<int> v1 = {1, 2, 3, 4, 5};
std::vector<int> v2 = std::move(v1);
// v1 处于"有效但未指定"的状态
// 可以安全地:赋新值、销毁、调用无前置条件的操作
std::cout << "v1.size() = " << v1.size() << std::endl; // 通常为 0
std::cout << "v2.size() = " << v2.size() << std::endl; // 5
// 可以重新使用
v1 = {10, 20};
std::cout << "重新赋值后 v1.size() = " << v1.size() << std::endl;
}
int main() {
std::cout << "=== 值类别 ===" << std::endl;
value_category_demo();
std::cout << "\n=== 移动语义 ===" << std::endl;
move_demo();
std::cout << "\n=== 标准库移动 ===" << std::endl;
stl_move_demo();
std::cout << "\n=== 移动后状态 ===" << std::endl;
moved_from_state();
return 0;
}拷贝 vs 移动
| 特性 | 拷贝 | 移动 |
|---|---|---|
| 操作 | 分配新内存,复制数据 | 转移指针,置空源对象 |
| 时间复杂度 | O(n) | O(1) |
| 源对象状态 | 不变 | 有效但未指定 |
| 触发条件 | 传入左值 | 传入右值或 std::move |
| 函数签名 | T(const T&) | T(T&&) noexcept |
常见问题
右值引用变量本身是左值还是右值?
左值。虽然类型是 T&&,但有名字的变量都是左值。要把它当右值传递,需要 std::move()。
移动构造函数为什么要标记 noexcept?
因为标准库容器(如 vector)在扩容时,只有在移动构造标记了 noexcept 时才会使用移动而不是拷贝。如果移动可能抛异常,容器为了保证异常安全会退回使用拷贝。
移动后的对象还能用吗?
可以,但只能执行"无前置条件"的操作:析构、赋新值、检查状态(如 size())。不能假设它有任何特定值。
适用场景
- 返回大对象(编译器可能用 RVO,但移动是兜底)
- 容器元素的插入和扩容
- 资源所有权的转移
- 临时对象的资源复用
注意事项
- 移动构造和移动赋值应标记
noexcept - std::move 本身不移动任何东西,只是类型转换
- 移动后的对象必须处于可析构的状态
- 基本类型(int、double 等)的移动和拷贝一样
- 不要对 const 对象使用 std::move(会退化为拷贝)
总结
右值引用(T&&)绑定到临时对象,移动语义通过"偷走"临时对象的资源避免深拷贝。移动构造/赋值的关键是:转移资源指针、置空源对象。面试中要能区分左值和右值、理解右值引用变量本身是左值、知道 std::move 只是类型转换、移动构造应标记 noexcept、移动后对象处于有效但未指定状态。