数据结构库——智能指针的实现（下）

1，SmartPointer 被设计成每次只允许一个智能指针对象指向一片堆空间，也就限制了智能指针的运用，不能够运用于LinkList；

  

2，本节完成 SharedPointer 的具体实现：

 

3，SharedPointer 设计要点：

       1，类模板:

              1，通过计数机制（ref）标识堆空间；

                     1，堆内存被指向时：ref++；

                     2，指针被置空时：ref--；

                     3，ref == 0 时：释放堆内存；          

4，计数机制原理剖析：

      

       1，计数变量和堆空间对象生命周期完全一样，且都在堆空间中声明的；

      

5，SharedPointer 类的声明：

       

      

6，智能指针比较：

       1，由于 SharedPointer 支持多个对象同时指向一片堆空间，因此必须支持比较操作；

7，SharedPointer 智能指针的实现：

#ifndef SHAREDPOINTER_H
#define SHAREDPOINTER_H

#include "Pointer.h"
#include <cstdlib>
#include "Exception.h"

namespace DTLib
{

template <typename T>
class SharedPointer : public Pointer<T>
{
protected:
　　 int* m_ref;  // 指向堆空间的计数变量，和对象相关联且同生命周期；

    void assign(const SharedPointer<T>& obj)
    {
        this->m_ref = obj.m_ref;
        this->m_pointer = obj.m_pointer;

        if( this->m_ref )  // obj 也可能为空；
        {
            (*this->m_ref)++;  
        }
　　 }

public:
　　 SharedPointer(T* p = NULL) : m_ref(NULL)  // 用初始化列表来初始化成员变量;调用时用堆空间指针来初始化参数 p
    {
        if( p )
        {
            this->m_ref = static_cast<int*>(std::malloc(sizeof(int)));  // 申请堆空间给计数指针指向

            if( this->m_ref )
            {
                this->m_pointer = p;

                *(this->m_ref) = 1;  // 这里不能为 *(this->m_ref)++;，因为里面是随机值，而如果重新申请，则必然首先为 1，++只是为了后来的拷贝赋值而准备的；
            }
            else
            {
                THROW_EXCEPTION(NoEnoughMemoryException, "No memory to creat SharedPointer object ...");
            }
        }
　　 }

    SharedPointer(const SharedPointer<T>& obj) : Pointer<T>(NULL)  // 初始化赋值调用，这里为了消除警告所以显示调用父类构造函数
    {
        assign(obj);
　　 }

　　 SharedPointer<T>& operator= (const SharedPointer<T>& obj)// 由于 SharedPointer 支持多个对象同时指向一片堆空间，因此必须支持比较操作；
　　 {
        if( this != &obj)
        {
            clear();  // 当前指针可能指向了别的对象，所以赋值前先让其不再指向别的对象，先清空，这样避免指向的别的对象的内存泄漏；
            assign(obj);
        }

        return *this;
　　 }

    void clear()  // 将当前指针置为空；
    {
        int* ref = this->m_ref;
        T* toDel = this->m_pointer;
        this->m_ref = NULL;
        this->m_pointer = 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)
{
    return !(l == r); // 不相等操作符重载使用相等操作符来实现；
}

}

#endif // SHAREDPOINTER_H

8，SharedPointer 的测试代码：

#include <iostream>
#include "SharedPointer.h"

using namespace std;
using namespace DTLib;

class Test : public Object
{
public:
　　 int value;

    Test() : value(0)
    {
        cout << "Test()" << endl;
　　 }

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

int main()
{
    SharedPointer<Test> sp0(new Test());
    SharedPointer<Test> sp1 = sp0;
　　 SharedPointer<Test> sp2 = NULL;

    sp2 = sp1;
　　 sp2->value = 100;

    cout << sp0->value << endl;
    cout << sp1->value << endl;
    cout << sp2->value << endl;
　　 cout << (sp0 == sp1) << endl;

　　 sp2.clear();

    cout << (sp0 == sp2) << endl;
    const SharedPointer<Test> sp3 = new Test();
　　 sp3->value = 100;

    return 0;
}

9，智能指针使用军规：

       1，智能用来指向堆空间中的单个变量（对象）；

       2，不同类型的智能指针对象不能混合使用；

       3，不要使用 delete 释放智能指针指向的堆空间；

      

10，小结：

       1，SharedPointer 最大程度的模拟了原生指针的行为；

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

　　3，智能指针只能用于指向堆空间中的内存；

       4，不同类型的智能指针不要混合使用；

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