c++ 移动赋值/移动构造函数

在 C++11 引入移动语义（Move Semantics） 之前，对象之间的赋值或初始化通常涉及深拷贝（Deep Copy） ，即复制所有数据。这对于包含动态分配资源（如 std::vector, std::string, 原始指针管理的内存）的对象来说，开销很大。

移动构造函数 和移动赋值运算符允许我们将资源的"所有权"从一个对象转移到另一个对象，而不是复制数据。这极大地提高了性能，特别是对于临时对象（右值）。

1. 核心概念：左值 vs 右值

理解移动语义的前提是区分左值（lvalue）和右值（rvalue）：

• 左值 ：有名字、有持久地址的对象（如 int a = 10; 中的 a）。
• 右值 ：通常是临时对象、字面量或即将销毁的对象（如 a + b 的结果，或者函数返回的非引用对象）。

移动语义的核心思想是：既然右值（临时对象）马上就要销毁了，我们没必要复制它的资源，直接"偷"过来用就行了。

2. 移动构造函数 (Move Constructor)

定义 ：当一个新对象被一个右值 初始化时调用。
签名 ：ClassName(ClassName&& other)
参数 ：接受一个右值引用（T&&）。

作用

将源对象（other）的资源指针直接转移给新对象，并将源对象的指针置为 nullptr（或其他安全状态），防止析构时重复释放内存。

代码示例

class MyVector {
private:
    int* data;
    size_t size;

public:
    // 构造函数
    MyVector(size_t s) : size(s) {
        data = new int[s];
        std::cout << "构造: 分配内存\n";
    }

    // 拷贝构造函数 (深拷贝)
    MyVector(const MyVector& other) : size(other.size) {
        data = new int[size];
        std::copy(other.data, other.data + size, data);
        std::cout << "拷贝构造: 深拷贝内存\n";
    }

    // --- 移动构造函数 ---
    MyVector(MyVector&& other) noexcept 
        : data(other.data), size(other.size) {
        // 关键步骤：窃取指针
        other.data = nullptr; // 将源对象置为空，防止其析构时释放这块内存
        other.size = 0;
        std::cout << "移动构造: 转移所有权\n";
    }

    // 析构函数
    ~MyVector() {
        if (data) {
            delete[] data;
            std::cout << "析构: 释放内存\n";
        }
    }
};

// 使用场景
MyVector createVector() {
    MyVector temp(100);
    return temp; // 返回临时对象（右值）
}

int main() {
    // 这里会触发移动构造函数，而不是拷贝构造
    MyVector v = createVector(); 
    return 0;
}

3. 移动赋值运算符 (Move Assignment Operator)

定义 ：当一个已存在的对象被赋予一个右值 时调用。
签名 ：ClassName& operator=(ClassName&& other)
返回值 ：通常返回 *this 以支持链式赋值。

作用

1. 自赋值检查 ：防止 a = std::move(a) 导致错误。
2. 清理旧资源：释放当前对象持有的旧资源。
3. 窃取新资源：接管源对象的资源。
4. 重置源对象：将源对象置于有效但未指定的状态（通常指针置空）。

代码示例

class MyVector {
    // ... (同上) ...

public:
    // --- 移动赋值运算符 ---
    MyVector& operator=(MyVector&& other) noexcept {
        if (this != &other) { // 1. 自赋值检查
            // 2. 释放当前资源
            delete[] data;
            
            // 3. 窃取资源
            data = other.data;
            size = other.size;
            
            // 4. 重置源对象
            other.data = nullptr;
            other.size = 0;
        }
        std::cout << "移动赋值: 转移所有权\n";
        return *this;
    }
};

int main() {
    MyVector v1(10);
    MyVector v2(20);
    
    // std::move 将左值 v1 强制转换为右值引用，触发移动赋值
    v2 = std::move(v1); 
    
    // 此时 v1 内部指针为 null，v2 拥有了原本 v1 的内存
    return 0;
}

4. 关键细节与最佳实践

A. noexcept 的重要性

移动构造函数和移动赋值运算符必须 标记为 noexcept（除非你真的可能抛出异常）。

• 原因 ：标准库容器（如 std::vector）在扩容重新分配内存时，如果元素的移动操作是 noexcept 的，它会优先使用移动 ；否则，为了保证异常安全（如果移动中途失败，原数据还在），它只能退回到拷贝。
• 如果不加 noexcept，std::vector<MyVector> 的性能可能会退化回拷贝语义。

B. std::move 是什么？

std::move 不移动任何东西 。它只是一个强制类型转换工具，将左值转换为右值引用（T&&），从而告诉编译器："这个对象我可以被移动，请调用移动版本的操作"。

• 调用 std::move(x) 后，x 处于有效但未指定 的状态。除了销毁或重新赋值外，不应再使用 x 的值。

C. 规则之五 (Rule of Five)

如果你需要自定义以下五个函数中的任何一个，通常意味着你需要自定义全部五个：

1. 析构函数
2. 拷贝构造函数
3. 拷贝赋值运算符
4. 移动构造函数
5. 移动赋值运算符

如果你只定义了移动操作而没有定义拷贝操作，编译器会自动删除默认的拷贝构造和拷贝赋值函数（因为资源已经被移走了，默认拷贝是不安全的）。

D. 成员变量的自动移动

如果你的类成员变量本身支持移动语义（如 std::unique_ptr, std::vector, std::string），你可以使用 default 让编译器自动生成高效的移动操作：

class MyClass {
    std::vector<int> vec;
    std::string name;
    // 编译器自动生成的移动构造/赋值会分别调用 vec 和 name 的移动操作
    // 非常高效且安全
    MyClass(MyClass&&) = default; 
    MyClass& operator=(MyClass&&) = default;
};

总结对比

特性	拷贝构造/赋值	移动构造/赋值
参数类型	const T& (左值引用)	T&& (右值引用)
行为	深度复制数据 (Deep Copy)	转移资源所有权 (Steal Pointers)
源对象状态	保持不变	变为有效但未指定状态 (通常为空)
性能	较慢 (涉及内存分配和复制)	极快 (仅指针赋值)
适用场景	需要保留源对象数据时	源对象是临时值或不再需要时