数据结构--另一种智能指针-SharedPointer

上一篇讲了最多只能由一个指针标识堆空间的SmartPointer，本篇讲解另一种智能指针--SharedPointer。

设计要点：

使用类模板实现。

继承自Pointer类

通过计数机制（ref）标识堆空间：被指向时ref++；指向的指针被置空时ref--；当计数变量ref为0时堆空间应该被释放。所以计数变量和堆空间对象是绑定在一起。

由于SharedPointer支持多个对象同时指向一片堆空间，所以需要支持比较操作，所以需要实现比较操作符重载。

由于const对象会使用指针操作符，所以需要重载const版本的（->）和（*）操作符重载。

由于需要重载比较操作符，需要将Pointer类的get函数和isNull函数做成const成员函数。

SharedPointer类声明及完整实现：

 template <typename T>
    class SharedPointer : public Pointer<T>
    {
      protected:
        int* m_ref;//计数变量

    public:
        SharedPointer(T* p = NULL) : m_ref(NULL)
        {
            if(p)
            {
                this->m_ref = static_cast<int*>(malloc(sizeof(int)));
                if(this->m_ref)
                {
                    (*this->m_ref) = 1;//申请空间成功后表示已经有指针指向它，计数变量加1。
                    this->m_pointer = p;
                }
                else//抛出异常
                {
                    THROW_EXCEPTION(NoEnoughMemoryException,"No enough memory to create...");
                }

            }
        }

        SharedPointer(const SharedPointer<T>& obj):Pointer<T>(NULL)//拷贝构造，拷贝成功后计数变量加1
        {
            this->m_ref = obj.m_ref;
            this->m_pointer = obj.m_pointer;
            if(this->m_ref)
                (*this->m_ref)++;
        }

        SharedPointer<T>& operator= (const SharedPointer<T>& obj)//赋值操作符重载，赋值成功后计数变量加1
        {
            if(this != &obj)
            {
                clear();//清理当前指向
                this->m_pointer = obj.m_pointer;//重新赋值
                this->m_ref = obj.m_ref;

                (*this->m_ref)++;
            }
            return *this;
        }
        void clear()//清除当前对象指向的空间，当计数变量为0时释放堆空间和计数变量占用的空间
        {
            T* toDel = this->m_pointer;
            int* ref = this->m_ref;//

            this->m_pointer = NULL;
            this->m_ref = NULL;//两步操作执行后计数变量数值不变。
            if(ref)//清理指向堆空间的指针
            {
               ( *ref)--;

                if((*ref) == 0)
                {
                    free(ref);
                    delete(toDel);

                }
            }
        }
        ~SharedPointer()
        {

            clear();
        }

    };
    //比较操作符重载，作为全局重载函数
    template <typename T>
    bool operator == (const SharedPointer<T>& l, const SharedPointer<T>& r)
    {
        return (l.get() == r.get());
    }

    template <typename T>
    bool operator != (const SharedPointer<T>& l, const SharedPointer<T>& r)//const对象只能调用const成员函数
    {
        return !(l == r);
    }

程序分析见注释内容。

SharedPointer最大程度的模拟了原生指针的行为。

计数机制确保多个智能指针合法的指向同一片堆空间。

堆对象的生命周期由智能指针进行管理。

实现了自动管理内存。

使用军规：

只能用来指向堆空间中的单个变量或对象，不能是栈等内存。

不同类型的智能指针对象不能混合使用，SmartPointer对象和SharedPointer对象不能混合使用。

在使用智能指针后不要使用delete释放智能指针指向的堆空间。

测试代码：

class Test : public Object
{

public:
    int value;
    Test():value(0)
    {

        cout << "Test()" << endl;
    }

    Test(int value)
    {
        this->value = value;
        cout << "Test()" << endl;
    }

    ~Test()
    {

        cout << "~Test()" << endl;
    }
};

int main()
{
    SharedPointer<Test> sp = new Test();

    SharedPointer<Test> nsp = NULL;
    nsp = sp;


    cout << sp->value << endl;
    cout << nsp->value << endl;

    nsp->value = 100;


    cout << sp->value << endl;
    cout << nsp->value << endl;

    cout << (sp == nsp) << endl;

    nsp.clear();

    cout << (sp == nsp) << endl;

    cout << endl;
 
    const SharedPointer <Test> pp = new Test(111);

    //(pp->value) = 100;//const对象不能修改成员变量的值，可以加上mutable强制破除只读属性。


    cout << pp->value << endl;

输出结果：

Test()
0
0
100
100
1
0

Test()
111
~Test()
~Test()

请自行对照结果分析原因。

小结：

这两篇内容重新设计了智能指针，使得智能指针在使用中更安全和方便。