如何设计一个不允许拷贝，但允许移动的类？

博主介绍：程序喵大人

• 35 - 资深C/C++/Rust/Android/iOS客户端开发
• 10年大厂工作经验
• 嵌入式/人工智能/自动驾驶/音视频/游戏开发入门级选手
• 《C++20高级编程》《C++23高级编程》等多本书籍著译者
• 更多原创精品文章，首发gzh，见文末
• 👇👇记得订阅专栏，以防走丢👇👇
  😉C++基础系列专栏
  😃C语言基础系列专栏
  🤣C++大佬养成攻略专栏
  🤓C++训练营
  👉🏻个人网站

在现代C++编程中，设计"不可拷贝但可移动"的类是一个非常重要的技术模式。这种设计模式特别适用于管理独占资源（如文件句柄、网络连接、动态内存等）的场景，能够显著提升程序的安全性，性能也会很有提升。

为什么需要不可拷贝但可移动的类？

在C++的传统编程中，拷贝操作是默认的，但这在某些场景下会带来问题：

1. 资源独占性：某些资源（如文件句柄、网络连接、互斥锁）不应该被多个对象同时管理，否则会导致资源竞争或双重释放的问题。
2. 性能考虑：对于管理大量内存或其他昂贵资源的类，拷贝操作的成本很高，而移动操作可以实现高效的资源转移。
3. 语义清晰性：明确表达对象的所有权语义，使代码更加清晰和安全。

核心实现原理

要实现"不可拷贝但可移动"的类，我们需要使用C++11引入的两个重要特性：

• =delete语法：显式删除拷贝构造函数和拷贝赋值运算符
• 移动语义：实现移动构造函数和移动赋值运算符

关键设计要点

1. 使用=delete显式禁止拷贝操作

// 禁用拷贝构造函数
UniqueBuffer(const UniqueBuffer&) = delete;

// 禁用拷贝赋值运算符
UniqueBuffer& operator=(const UniqueBuffer&) = delete;

这种方式比C++11之前的"私有拷贝构造+不实现"方式更加清晰和安全：

• 编译错误信息更加明确
• 错误发生在调用点，而不是链接点
• 表达了明确的设计意图

2. 实现高效的移动操作

// 移动构造函数
UniqueBuffer(UniqueBuffer&& other) noexcept
    : data_(other.data_), size_(other.size_) {
    other.data_ = nullptr;
    other.size_ = 0;
}

// 移动赋值运算符
UniqueBuffer& operator=(UniqueBuffer&& other) noexcept {
    if (this != &other) {
        delete[] data_;        // 释放当前资源
        data_ = other.data_;   // 转移资源
        size_ = other.size_;
        other.data_ = nullptr; // 重置源对象
        other.size_ = 0;
    }
    return *this;
}

3. 使用noexcept关键字

移动操作应该标记为noexcept，这是因为：

• 标准库容器在重新分配内存时，只有当移动操作是noexcept的才会使用移动语义，否则会退回到拷贝操作
• 可以提升容器操作的效率
• 向调用者承诺不会抛出异常

UniqueBuffer(UniqueBuffer&& other) noexcept  // 重要！
    : data_(other.data_), size_(other.size_) {
    // ...
}

移动语义的工作原理

移动语义的核心思想是"资源所有权的转移"而不是"资源的复制"：

1. 右值引用：T&&类型的参数可以绑定到临时对象或std::move()转换的对象
2. 资源转移：移动操作直接转移资源指针或句柄，而不是复制资源内容
3. 源对象重置：将源对象置于"有效但不确定"的状态，确保可以安全析构

实际应用场景

1. 文件句柄管理

class FileHandle {
private:
    FILE* file_;
public:
    explicit FileHandle(const char* filename) {
        file_ = fopen(filename, "r");
        if (!file_) throw std::runtime_error("无法打开文件");
    }

    // 禁用拷贝
    FileHandle(const FileHandle&) = delete;
    FileHandle& operator=(const FileHandle&) = delete;

    // 允许移动
    FileHandle(FileHandle&& other) noexcept : file_(other.file_) {
        other.file_ = nullptr;
    }

    ~FileHandle() {
        if (file_) fclose(file_);
    }
};

2. 网络连接管理

class NetworkConnection {
private:
    int socket_fd_;
public:
    explicit NetworkConnection(int fd) : socket_fd_(fd) {}

    // 禁用拷贝，启用移动
    NetworkConnection(const NetworkConnection&) = delete;
    NetworkConnection& operator=(const NetworkConnection&) = delete;

    NetworkConnection(NetworkConnection&& other) noexcept
        : socket_fd_(other.socket_fd_) {
        other.socket_fd_ = -1;
    }

    ~NetworkConnection() {
        if (socket_fd_ >= 0) close(socket_fd_);
    }
};

3. 独占内存缓冲区

class UniqueBuffer {
private:
    void* buffer_;
    size_t size_;
public:
    explicit UniqueBuffer(size_t size)
        : buffer_(std::malloc(size)), size_(size) {
        if (!buffer_) throw std::bad_alloc();
    }

    // 禁用拷贝，启用移动
    UniqueBuffer(const UniqueBuffer&) = delete;
    UniqueBuffer& operator=(const UniqueBuffer&) = delete;

    UniqueBuffer(UniqueBuffer&& other) noexcept
        : buffer_(other.buffer_), size_(other.size_) {
        other.buffer_ = nullptr;
        other.size_ = 0;
    }

    ~UniqueBuffer() {
        if (buffer_) std::free(buffer_);
    }
};

码字不易，欢迎大家点赞，关注，评论，谢谢！