C++ std::exchange在实现移动操作中的惯用法

std::exchange 是 C++14 引入的一个实用工具，它允许你原子性地替换一个对象的值，并返回被替换前的旧值。这个看似简单的功能，在实现 C++ 的移动语义时，能够极大地简化代码，提升安全性和可读性。

认识 std::exchange

std::exchange 的核心作用是“替换并返回旧值”。它的函数签名类似于：

template <class T, class U = T>
constexpr T exchange(T& obj, U&& new_value);

当你调用 std::exchange(t, u) 时，它会执行以下两步操作：

1. 将 t 的值替换为 u。
2. 返回 t 在被替换前的旧值。

这比先保存旧值，再赋新值，最后返回旧值的传统方式要简洁得多。

示例：

假设你有一个整数 a，值为 10。你想把它替换为 20，并记住它原来的值。

#include <utility> // 包含 std::exchange

int main() {
    int a = 10;
    int old_value = std::exchange(a, 20);
    // 现在 a 的值是 20
    // old_value 的值是 10
}

移动语义的挑战

在 C++ 中，移动语义允许你将资源的所有权从一个对象转移到另一个对象，而不是进行昂贵的复制。这通常通过移动构造函数和移动赋值运算符来实现。

对于持有动态资源的类（如指针、文件句柄等），手动实现这些操作可能会很繁琐，并且容易出错。关键挑战在于：你需要将源对象的资源“偷走”，并正确地释放目标对象原有的资源。

一个常见的错误是忘记处理自赋值的情况，或者在进行资源交换时，不小心释放了即将要转移的资源。

一个“糟糕”的移动赋值运算符实现示例：

class ResourceHolder {
public:
    ResourceHolder() : data_(nullptr) {}
    ~ResourceHolder() { delete data_; }

    // 糟糕的移动赋值运算符
    ResourceHolder& operator=(ResourceHolder&& other) {
        // 1. 释放当前对象的资源
        delete data_;

        // 2. 从 other "偷走" 资源
        data_ = other.data_;
        other.data_ = nullptr;

        return *this;
    }

private:
    int* data_;
};

这个实现看起来没问题，但如果发生自赋值（holder = std::move(holder);），就会出问题。在 delete data_; 这一步，你释放了 holder 自己的资源，但紧接着你又把 other.data_（也就是 holder.data_）赋给了 data_，这会导致你释放了一个已经无效的指针，然后又指向了它，造成未定义行为。

std::exchange 的惯用法

std::exchange 的强大之处在于，它能将“获取新资源”和“释放旧资源”这两个步骤原子性地完成，完美地解决了上述问题。

1. 实现移动构造函数

移动构造函数的目标是从另一个对象 other 中“偷走”资源，并让 other 处于一个有效的、可析构的状态（通常是 nullptr）。

使用 std::exchange：

ResourceHolder(ResourceHolder&& other) noexcept
    : data_(std::exchange(other.data_, nullptr)) {
    // data_ 现在持有资源
    // other.data_ 被设置为 nullptr
}

std::exchange(other.data_, nullptr) 这一行代码完成了所有工作：

• 它将 other.data_ 的值（即资源指针）赋给 this->data_。
• 同时，它将 other.data_ 的值设置为 nullptr。
• 最后，它返回 other.data_ 的旧值（即资源指针），并赋给 this->data_。

整个过程清晰、安全，没有中间状态。

2. 实现移动赋值运算符

移动赋值运算符更复杂，因为它需要处理自赋值，并正确释放目标对象原有的资源。std::exchange 在这里能大显身手。

使用 std::exchange：

ResourceHolder& operator=(ResourceHolder&& other) noexcept {
    if (this != &other) { // 检查自赋值
        // 1. 释放当前对象的资源
        delete data_;

        // 2. 从 other "偷走" 资源，并设置 other 为空
        data_ = std::exchange(other.data_, nullptr);
    }
    return *this;
}

让我们分析这一行 data_ = std::exchange(other.data_, nullptr);：

• 它首先获取 other.data_ 的旧值（即资源指针）。
• 然后，它将 other.data_ 设置为 nullptr。
• 最后，它将获取到的旧值赋给 this->data_。

这个操作是原子的。你永远不会在“释放旧资源”和“获取新资源”之间，处于一个资源既被释放又被指向的尴尬状态。即使发生了自赋值，if (this != &other) 会阻止执行，从而避免了问题。

完整示例

下面是一个完整的 MyString 类，它使用 std::exchange 实现了移动语义。

#include <iostream>
#include <cstring>
#include <utility> // for std::exchange

class MyString {
public:
    // 默认构造函数
    MyString() : data_(nullptr), size_(0) {}

    // 析构函数
    ~MyString() {
        delete[] data_;
    }

    // 禁用拷贝构造和拷贝赋值（为了强制使用移动语义）
    MyString(const MyString&) = delete;
    MyString& operator=(const MyString&) = delete;

    // 移动构造函数
    MyString(MyString&& other) noexcept
        : data_(std::exchange(other.data_, nullptr)),
          size_(std::exchange(other.size_, 0)) {
        std::cout << "Move Constructor called" << std::endl;
    }

    // 移动赋值运算符
    MyString& operator=(MyString&& other) noexcept {
        if (this != &other) {
            // 释放当前对象的资源
            delete[] data_;

            // 从 other "偷走" 资源
            data_ = std::exchange(other.data_, nullptr);
            size_ = std::exchange(other.size_, 0);
        }
        std::cout << "Move Assignment called" << std::endl;
        return *this;
    }

    // 用于演示的成员函数
    void print() const {
        if (data_) {
            std::cout << "String: " << data_ << ", Size: " << size_ << std::endl;
        } else {
            std::cout << "String is empty" << std::endl;
        }
    }

private:
    char* data_;
    size_t size_;
};

int main() {
    MyString s1;
    s1 = MyString("Hello, World!"); // 调用移动赋值
    s1.print();

    MyString s2 = std::move(s1); // 调用移动构造
    s1.print(); // s1 现在为空
    s2.print();

    // 自赋值测试
    s2 = std::move(s2);
    s2.print();

    return 0;
}

输出结果：

Move Assignment called
String: Hello, World!, Size: 13
Move Constructor called
String is empty
String: Hello, World!, Size: 13
Move Assignment called
String: Hello, World!, Size: 13

在这个例子中，std::exchange 确保了 s1 在资源被转移后，其内部指针 data_ 和 size_ 被正确地设置为 nullptr 和 0，使其处于一个安全、可析构的状态。

std::exchange 的优势总结

使用 std::exchange 实现移动操作具有以下显著优势：

std::exchange 是现代 C++ 中实现移动语义的推荐工具。它不仅让代码更简洁，更重要的是，它通过消除手动管理资源的潜在错误，使你的类更加健壮和安全。