shared ptr源码

下面是一个简单的 shared_ptr 的实现，供参考：

template<typename T>
class shared_ptr {
public:
    shared_ptr() : ptr_(nullptr), ref_count_(nullptr) {}

    explicit shared_ptr(T* ptr) : ptr_(ptr) {
        ref_count_ = new int(1);
    }

    shared_ptr(const shared_ptr<T>& other) : ptr_(other.ptr_), ref_count_(other.ref_count_) {
        ++(*ref_count_);
    }

    ~shared_ptr() {
        release();
    }

    shared_ptr<T>& operator=(const shared_ptr<T>& other) {
        if (this != &other) {
            release();
            ptr_ = other.ptr_;
            ref_count_ = other.ref_count_;
            ++(*ref_count_);
        }
        return *this;
    }

    T* get() const {
        return ptr_;
    }

    void reset() {
        release();
        ptr_ = nullptr;
        ref_count_ = nullptr;
    }

    bool operator==(const shared_ptr<T>& other) const {
        return ptr_ == other.ptr_;
    }

    bool operator!=(const shared_ptr<T>& other) const {
        return !(*this == other);
    }

    T& operator*() const {
        return *ptr_;
    }

    T* operator->() const {
        return ptr_;
    }

    int use_count() const {
        return *ref_count_;
    }

private:
    void release() {
        if (ref_count_ && --(*ref_count_) == 0) {
            delete ptr_;
            delete ref_count_;
        }
    }

private:
    T* ptr_;
    int* ref_count_;
};

这个实现中，我们使用一个计数器 ref_count_ 来记录当前有多少个 shared_ptr 共享一个对象。每当有一个新的 shared_ptr 被创建时，计数器会加一。每当一个 shared_ptr 被销毁时，计数器会减一。只有当计数器为 0 时，才会销毁对象。在拷贝构造函数和赋值操作符中，我们需要注意将计数器加一。在析构函数中，我们需要注意将计数器减一，并在计数器为 0 时销毁对象和计数器。