通过引用计数实现智能指针

通过模板和引用计数的方式实现智能指针，需要两个类：智能指针类SmartPtr，和智能指针辅助类SmartPtrHelper，其中用户接触到是SmartPtr类，而SmartPtr类通过SmartPtrHelper管理指针的内存和计数。具体实现如下：

SmartPtrHelper类

//模板类作为友元时要先有声明
template <typename T>
class SmartPtr;

template <typename T>
class SmartPtrHelper //辅助类
{
  private:
    //该类成员访问权限全部为private，因为不想让用户直接使用该类
    friend class SmartPtr<T>; //定义智能指针类为友元，因为智能指针类需要直接操纵辅助类

    //构造函数的参数为基础对象的指针
    SmartPtrHelper(T *ptr) : p(ptr), count(1) {}

    //析构函数
    ~SmartPtrHelper()
    {
        delete p;
        p = nullptr;
    }
    //引用计数
    int count = 0;

    //基础对象指针
    T *p = nullptr;
};

SmartPtr类

template <typename T>
class SmartPtr //智能指针类
{
public:
    SmartPtr(T *ptr) : rp(new SmartPtrHelper<T>(ptr)) {}         //构造函数
    SmartPtr(const SmartPtr<T> &sp) : rp(sp.rp) { ++rp->count; } //复制构造函数，在初始化列表中，将已经管理指针的智能指针对象赋值给新的智能指针对象，顺利的完成了引用计数的传递。
                                                                 //进而，在函数体中将自己的引用计数进行++操作，完成了引用计数与实际被管理对象个数的同步。
    SmartPtr &operator=(const SmartPtr<T> &rhs)
    {                         //重载赋值操作符
        ++rhs.rp->count;      //首先将右操作数引用计数加1，
        if (--rp->count == 0) //然后将引用计数减1，可以应对自赋值
            delete rp;
        rp = rhs.rp;
        return *this;
    }

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

    ~SmartPtr() //析构函数
    {                         
        if (--rp->count == 0) //当引用计数减为0时，删除辅助类对象指针，从而删除基础对象
        {
            delete rp;
        }
        else
        {
            cout << "还有" << rp->count << "个指针指向基础对象" << endl;
        }
    }

private:
    SmartPtrHelper<T> *rp = nullptr; //辅助类对象指针
};