一个简单的智能指针的实现

#include <iostream>

using namespace std;


// 一个简单的智能指针的实现
template <class T>
class SmartPtr
{
public:
    // 构造函数：p是指向已经动态创建的int对象指针
    SmartPtr(T *p) : m_pHelpPtr(new HelpPtr<T>(p))
    {
    }

    // 复制构造函数：复制成员并将使用计数加1
    SmartPtr(const SmartPtr& orig) : m_pHelpPtr(orig.m_pHelpPtr)
    {
        ++m_pHelpPtr->refCount;
    }

    // 赋值操作符
    SmartPtr& operator=(const SmartPtr& rhs)
    {
        // 增加右操作数中的使用计数
        ++rhs.m_pHelpPtr->refCount;
        // 将左操作数对象的使用计数减1，若该对象的使用计数减至0，则删除该对象
        if (--m_pHelpPtr->refCount == 0)
            delete m_pHelpPtr;
        m_pHelpPtr = rhs.m_pHelpPtr;   // 复制HelpPtr指针
        return *this;
    }

    // 析构函数：如果计数为0，则删除HelpPtr对象
    ~SmartPtr()
    {
        if (--m_pHelpPtr->refCount == 0)
            delete m_pHelpPtr;
    }


    T& operator *()        //重载*操作符
    {
        return *(m_pHelpPtr->ptr);
    }
    T* operator ->()       //重载->操作符
    {
        return m_pHelpPtr->ptr;
    }

private:

    // 一个助手类，实现了引用计数，存放了实际的数据
    template <class X>
    class HelpPtr
    {
    public:
        X *ptr;
        size_t refCount;
        HelpPtr(X *p) : ptr(p) , refCount(1)
        {
            //cout << "HelpPtr constructor called !" << endl;
        }
        ~HelpPtr()
        {
            delete ptr;
            //cout << "HelpPtr distructor called !" << endl;
        }
    };
    HelpPtr<T> *m_pHelpPtr;   //指向使用计数类HelpPtr
};




int main(void)
{

    {
        int *pi = new int(42);
        SmartPtr<int> p = pi;
        p = p;
        cout << *p << endl;
        SmartPtr<int> p1 = p;
        SmartPtr<int> p2 = p1;
        p = p2;

        p1 = p;
        p2 = p1;

        p1 = p2;
        p2 = p1;

    }

    return 0;
}