shared_ptr自定义实现

/**
 * 智能指针中的引用计数类
 */

class RefCount {
public:
    RefCount() : count_(new size_t(1)) {}

    // 拷贝构造
    RefCount(const RefCount &rhs) : count_(rhs.count_) {
        (*count_)++;
    }

    // 移动构造
    RefCount(RefCount &&rhs) : count_(rhs.count_) {
        rhs.count_ = nullptr;
    }

    // 拷贝赋值
    RefCount &operator=(const RefCount &rhs) {
        tryRelease();
        count_ = rhs.count_;
        (*count_)++;
        return *this;
    }

    // 移动赋值
    RefCount &operator=(RefCount &&rhs) {
        tryRelease();
        count_ = rhs.count_;
        rhs.count_ = nullptr;
        return *this;
    }

    ~RefCount() {
        if (*count_ == 1) {
            delete count_;
            count_ = nullptr;
        } else {
            (*count_)--;
        }
    }

    size_t IsOnly() {
        return *count_ == 1;
    }

    // 尝试减少引用计数并释放内存
    void tryRelease() {
        if (count_ == nullptr) {
            return ;
        }
        if (*count_ == 1) {
            delete count_;
        } else {
            (*count_)--;
        }
    }

private :
    size_t* count_;
};

/**
 * 智能指针封装类
 */
template <typename T>
class SmartPtr {
public :
    // 默认构造函数
    SmartPtr() : SmartPtr(nullptr) {}

    // 原始构造函数
    explicit SmartPtr(T* ptr = nullptr) : ptr_(ptr) {}

    // 拷贝构造函数
    SmartPtr(const SmartPtr& rhs) {
        ptr_ = rhs.ptr_;
        count_ = rhs.count_;
    }

    // 移动构造函数
    SmartPtr(SmartPtr&& rhs) noexcept : ptr_(rhs.ptr_), count_(rhs.count_) {
        rhs.count_ = rhs.ptr_ = nullptr;
    }

    // 拷贝赋值
    SmartPtr& operator=(const SmartPtr& rhs) {
        if (count_.IsOnly()) {
            delete ptr_;
        } else {
            count_.tryRelease();
        }
        ptr_ = rhs.ptr_;
        count_ = rhs.count_;
        return *this;
    }

    // 移动赋值
    SmartPtr& operator=(const SmartPtr&& rhs) {
        if (this == &rhs) {
            return *this;
        }
        count_ = std::move(rhs.count_);
        ptr_ = rhs.ptr_;
        return *this;
    }

    ~SmartPtr() {
        std::cout << "SmartPtr deconstructor" << std::endl;
        if (count_.IsOnly()) {
            delete ptr_;
            ptr_ = nullptr;
        }
        count_.tryRelease();
    }

    // 解引用运算符*
    T& operator*() const {
        return *ptr_;
    }

    // 成员访问运算符->
    T* operator->() const {
        return ptr_;
    }

template<class T>
class Shared_Ptr {
public :
    Shared_Ptr(T* ptr = nullptr) : _pPtr(ptr), _pRefCount(new int(1)), _pMutex(new mutex) {}

    Shared_Ptr(const Shared_Ptr<T>& sp) : _pPtr(sp._pPtr), _pRefCount(sp._pRefCount), _pMutex(sp._pMutex) {
        AddRefCount();
    }

    ~Shared_Ptr() {
        Release();
    }

    Shared_Ptr<T>& operator=(const Shared_Ptr<T>& sp) {
        if (this != sp) {
            Release();
            _pPtr = sp._pPtr;
            _pRefCount = sp._pRefCount;
            _pMutex = sp._pMutex;
            AddRefCount();
        }
        return *this;
    }

    T& operator*() {
        return *_pPtr;
    }

    T* operator->() {
        return _pPtr;
    }

    int UseCount() { return *_pRefCount; }

    T* Get() { return _pPtr; }

    void AddRefCount() {
        _pMutex -> lock();
        ++(*_pRefCount);
        _pMutex -> unlock();
    }

private :
    void Release() {
        bool deleteflag = false;
        _pMutex -> lock();
        if (--(*_pRefCount) == 0) {
            delete _pRefCount;
            delete _pPtr;
            deleteflag = true;
        }
        _pMutex -> unlock();
        if (deleteflag == true) {
            delete _pMutex;
        }
    }

本文作者：jujimeizuo
本文地址： https://blog.jujimeizuo.cn/2022/07/30/shared-ptr/
本博客所有文章除特别声明外，均采用 CC BY-SA 3.0 协议。转载请注明出处！