c++ 移动赋值/移动构造函数的实现_C/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 以支持链式赋值。

作用

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

代码示例

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)

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

析构函数
拷贝构造函数
拷贝赋值运算符
移动构造函数
移动赋值运算符

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

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)
源对象状态	保持不变	变为有效但未指定状态 (通常为空)
性能	较慢 (涉及内存分配和复制)	极快 (仅指针赋值)
适用场景	需要保留源对象数据时	源对象是临时值或不再需要时