再论智能指针（上）

0.引言：

目的：使用智能指针替代LinkList中的原生的指针，

限制：但是我们的智能指针设定了只能单个指针指向某一片堆空间

 

1. 智能指针的继承层次结构

（1）Pointer是智能指针的抽象父类（模板）

　　①纯虚析构函数：virtual ~Pointer()=0;

　　②重载operator->()

　　③重载operator*()

 （2）类的声明

 

template <typename T>
class Pointer : public Object
{
protected:
    T* m_pointer;
public:
    Pointer(T* p = NULL);
    T* operator->();
    T& operator*();
    bool isNull();
    T* get();
   virtual ~Pointer()=0; 
};

 

2. SmartPointer的问题

（1）指针生命周期结束时主动释放堆空间

（2）一片堆空间最多只能由一个指针标识

（3）杜绝指针运算和指针比较

 

 3.【编程实验】

智能指针的新方案

//Pointer.h

 

#ifndef _POINTER_H_
#define _POINTER_H_
#include "Object.h"

namespace DataStructureLib
{
    template <typename T>
    class Pointer : public Object//Pointer不需实现析构函数 Object是析构函数本身是纯虚函数！
    {
    protected:
        T* m_pointer;
    public:
        Pointer(T* p = NULL)
        {
            m_pointer=p;
        }

        T* operator->()
        {
            return m_pointer;
        }    
        T& operator*()
        {
            return *m_pointer;
        }
        
        bool isNull()
        {
            return (m_pointer==NULL);
        }
    
        T* get()
        {
            return *m_pointer;
        }
        //virtual ~Pointer()=0;//Pointe可以省略这个析构函数 Object是析构函数本身是纯虚函数！，如果这里不提供析构函数的实现（编译器默认会有析构函数），这个Pointer类一直是个纯虚类
    };
}
#endif

//SmartPointer.h

#ifndef _SMARTPOINTER_H_
#define _SMARTPOINTER_H_

#include "Pointer.h"

namespace DataStructureLib {

    //智能指针
    template<typename T>
    class SmartPointer : public Pointer<T>
    {
    public:
        //构造函数  直接调用父类的构造函数
        SmartPointer(T* p = NULL):Pointer(p)
        {

        }

         //拷贝构造函数
        SmartPointer(const SmartPointer<T>& obj)
        {
            this->m_pointer=obj->m_pointer;

            //所有权转移，使得同一时刻只能由一个指针指向堆空间
            const_cast<SmartPointer<T> &>(obj).m_pointer=NULL;
        }

        SmartPointer<T>& operator=(const SmartPointer<T>& obj)
        {
            if (this!=&obj)
            {
                T* p=this->m_pointer;
                this->m_pointer=obj.m_pointer;
                //所有权转移
                const_cast<SmartPointer<T>&>(obj).m_pointer = NULL;
                delete p;
            }
            return *this;
        }
        
        ~SmartPointer()
        {
            delete m_pointer;
        }
    };
}


#endif

测试代码：

#include<iostream>
#include "object.h"
#include "SeqList.h"
#include "LinkList.h"
#include "SmartPointer.h"
using namespace std;
using namespace DataStructureLib;

class Test : public Object
{
public:
    Test()
    {
        cout << "Test()" << endl;
    }

    ~Test()
    {
        cout <<"~Test()" << endl;
    }
};
int main(int argc, char const *argv[])
{
    SmartPointer<Test> sp = new Test();
    SmartPointer<Test> spn;
    spn = sp;
    
    //system("pause"); 
    return 0;
}

结果