右值引用与移动语义基础 ​

面试考点 ​

右值引用和移动语义是 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、移动后对象处于有效但未指定状态。