[Effective C++]条款14:在资源管理类中小心coping行为

在C++中，RAII（Resources Acquisition Is Initialization - 资源获取即初始化）是一种重要的资源管理技术，它通过对象的生命周期来管理资源的获取和释放。当一个对象持有一个资源（如互斥锁）时，通常不希望该资源对象被拷贝或赋值，因为这可能导致资源的重复释放或竞争条件。对于这种场景，常见的处理方式有：

1、禁止拷贝

• 通过将拷贝构造函数和拷贝赋值运算符声明为delete，或者声明为private修复，可以禁止对象的拷贝和赋值操作。适用于资源不能被共享或赋值的情况。

#include <mutex>

class Lock {
public:
    explicit Lock(std::mutex& mtx) : mutex_(mtx) {
        mutex_.lock();
    }

    ~Lock() {
        mutex_.unlock();
    }

    // 禁止拷贝
    Lock(const Lock&) = delete;
    Lock& operator=(const Lock&) = delete;

private:
    std::mutex& mutex_;
};

int main() {
    std::mutex mtx;
    Lock lock1(mtx);
    // Lock lock2 = lock1; // 错误：拷贝构造函数被删除
    return 0;
}

2、采用std::shared_ptr共享方式管理资源

• 如果资源可以被多个对象共享，可以使用std::shared_ptr来管理资源，通过引用计数的方式来确保资源在所有持有者都释放后才被销毁。

#include <memory>
#include <mutex>

class Lock {
public:
    explicit Lock(std::mutex& mtx) : mutex_(std::make_shared<std::mutex>(mtx)) {
        mutex_->lock();
    }

    ~Lock() {
        mutex_->unlock();
    }

    // 允许拷贝
    Lock(const Lock& other) : mutex_(other.mutex_) {}

    Lock& operator=(const Lock& other) {
        if (this != &other) {
            mutex_ = other.mutex_;
        }
        return *this;
    }

private:
    std::shared_ptr<std::mutex> mutex_;
};

int main() {
    std::mutex mtx;
    Lock lock1(mtx);
    Lock lock2 = lock1; // 允许拷贝，共享同一个互斥锁
    return 0;
}

3、采用深拷贝方式，新创建一个资源对象

• 如果资源可以被复制，可以通过深拷贝的方式创建一个新的资源对象。这种方式适用于资源可以独立复制的情况。

#include <mutex>

class Lock {
public:
    explicit Lock(std::mutex& mtx) : mutex_(new std::mutex(mtx)) {
        mutex_->lock();
    }

    ~Lock() {
        mutex_->unlock();
    }

    // 深拷贝
    Lock(const Lock& other) : mutex_(new std::mutex(*other.mutex_)) {}

    Lock& operator=(const Lock& other) {
        if (this != &other) {
            *mutex_ = *other.mutex_;
        }
        return *this;
    }

private:
    std::unique_ptr<std::mutex> mutex_;
};

int main() {
    std::mutex mtx;
    Lock lock1(mtx);
    Lock lock2 = lock1; // 深拷贝，创建新的互斥锁
    return 0;
}

4、采用std::unique_ptr方式，让资源进行转移

• 适用于资源只能被一个对象持有的情况

#include <memory>
#include <mutex>

class Lock {
public:
    explicit Lock(std::mutex& mtx) : mutex_(new std::mutex(mtx)) {
        mutex_->lock();
    }

    ~Lock() {
        mutex_->unlock();
    }

    // 转移所有权
    Lock(Lock&& other) noexcept : mutex_(std::move(other.mutex_)) {}

    Lock& operator=(Lock&& other) noexcept {
        if (this != &other) {
            mutex_ = std::move(other.mutex_);
        }
        return *this;
    }

    // 禁止拷贝
    Lock(const Lock&) = delete;
    Lock& operator=(const Lock&) = delete;

private:
    std::unique_ptr<std::mutex> mutex_;
};

int main() {
    std::mutex mtx;
    Lock lock1(mtx);
    Lock lock2 = std::move(lock1); // 转移所有权
    return 0;
}

思维导图笔记：