智能指针

文章目录

template<class T>
class SharedPointer
{
public:
    SharedPointer():m_refCount(nullptr), m_pointer(nullptr) {}
    
    SharedPointer(T* adoptTarget):m_refCount(nullptr), m_pointer(adoptTarget) {
        addReference();
    }
    
    SharedPointer(const SharedPointer<T>& copy):m_refCount(copy.m_refCount), m_pointer(copy.m_pointer) {
        addReference();
    }
    
    virtual ~SharedPointer() {
        removeReference();
    }
    
    //赋值操作
    //当左值被赋值时，表明它不再指向所指的资源，故引用计数减一
    //之后，它指向了新的资源，所以对应这个资源的引用计数加一
    SharedPointer<T>& operator=(const SharedPointer<T>& that) {
        if (this != &that) {
            removeReference();
            this->m_pointer = that.m_pointer;
            this->m_refCount = that.m_refCount;
            addReference();
        }
        return *this;
    }
    
    
    //判断是否指向同一个资源
    bool operator==(const SharedPointer<T>& other) {
        return m_pointer == other.m_pointer;
    }
    bool operator!=(const SharedPointer<T>& other) {
        return !operator==(other);
    }
    
    //指针解引用
    T& operator*() const {
        return *m_pointer;
    }
    //调用所知对象的公共成员
    T* operator->() const {
        return m_pointer;
    }
    
    //获取引用计数个数
    int GetReferenceCount() const {
        if (m_refCount) {
            return *m_refCount;
        } else {
            return -1;
        }
    }
 protected:
    
    //当为nullpter时，创建引用计数资源，并初始化为1
    //否则，引用计数加1。
    void addReference() {
        if (m_refCount) {
            (*m_refCount)++;
        } else {
            m_refCount = new int(0);
            *m_refCount = 1;
        }
    }
    
    void removeReference() {
        if(m_refCount) {
            (*m_refCount)--;
            if(*m_refCount == 0) {
                delete m_refCount;
                delete m_pointer;
                m_refCount = 0;
                m_pointer = 0;
            }
        }
    }
private:
    int *m_refCount;
    T *m_pointer;
};