再论智能指针（上）

 1 template <typename T>
 2 class Pointer : public Object
 3 {
 4 protected:
 5     T* m_pointer;
 6 public:
 7     Pointer(T* p = NULL);
 8     T* operator->();
 9     T& operator*();
10     bool isNull();
11     T* get();
12    virtual ~Pointer()=0; 
13 };

#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

 1 #ifndef _SMARTPOINTER_H_
 2 #define _SMARTPOINTER_H_
 3 
 4 #include "Pointer.h"
 5 
 6 namespace DataStructureLib {
 7 
 8     //智能指针
 9     template<typename T>
10     class SmartPointer : public Pointer<T>
11     {
12     public:
13         //构造函数  直接调用父类的构造函数
14         SmartPointer(T* p = NULL):Pointer(p)
15         {
16 
17         }
18 
19          //拷贝构造函数
20         SmartPointer(const SmartPointer<T>& obj)
21         {
22             this->m_pointer=obj->m_pointer;
23 
24             //所有权转移，使得同一时刻只能由一个指针指向堆空间
25             const_cast<SmartPointer<T> &>(obj).m_pointer=NULL;
26         }
27 
28         SmartPointer<T>& operator=(SmartPointer<T>& obj)
29         {
30             if (this!=&obj)
31             {
32                 T* p=this->m_pointer;
33                 this->m_pointer=obj.m_pointer;
34                 //所有权转移
35                 const_cast<SmartPointer<T>&>(obj).m_pointer = NULL;
36                 delete p;
37             }
38             return *this;
39         }
40         
41         ~SmartPointer()
42         {
43             delete m_pointer;
44         }
45     };
46 }
47 
48 
49 #endif

 1 #include<iostream>
 2 #include "object.h"
 3 #include "SeqList.h"
 4 #include "LinkList.h"
 5 #include "SmartPointer.h"
 6 using namespace std;
 7 using namespace DataStructureLib;
 8 
 9 class Test : public Object
10 {
11 public:
12     Test()
13     {
14         cout << "Test()" << endl;
15     }
16 
17     ~Test()
18     {
19         cout <<"~Test()" << endl;
20     }
21 };
22 int main(int argc, char const *argv[])
23 {
24     SmartPointer<Test> sp = new Test();
25     SmartPointer<Test> spn;
26     spn = sp;
27     
28     //system("pause"); 
29     return 0;
30 }