C++智能指针实现方法

#pragmaonce

#include < iostream >
#include < stdexcept >
using namespace std;

#ifndefTEST_SMARTPTR
#define TEST_SMARTPTR
#endif

template < class T >
class TSmartPtr
{
public :
// 默认构造函数
TSmartPtr(T * pTObject = NULL):m_pTObject(pTObject),m_pCount( new int ( 1 )){}
// 拷贝构造函数
TSmartPtr( const TSmartPtr & src):m_pTObject(src.m_pTObject),m_pCount(src.m_pCount){ ++ ( * m_pCount);}
// 析构函数
virtual ~ TSmartPtr()
{
#ifdefTEST_SMARTPTR
cout << " SmartPtrObjectFree. " << endl;
#endif
DoDecUseCount();
}
// =重载
TSmartPtr & operator = ( const TSmartPtr & rhs)
{
// self-assigningisalsoright
++* rhs.m_pCount; // 源智能指针的引用计数增1
DoDecUseCount(); // 目标智能指针的引用计数减1。此非常有必要。因为该指针既然要指向rhs，
// 则说明它就不再想去管理自身原本的指针对象了。因此需要减1()
// 在自身引用计数减1后，有可能自身原本维护的指针对象会被释放掉，也有可能不会。
// (因为，先前所管理的对象，有可能还有其他的智能指针对象在维护着了。)
// 因此，上面这两句才是精髓。
m_pTObject = rhs.m_pTObject;
m_pCount = rhs.m_pCount;
return * this ;
}
// ->重载
T * operator -> ()
{
if (NULL != m_pTObject)
return m_pTObject;
throw runtime_error( " accessthroughNULLpointer " );
}
const T * operator -> () const
{
if (NULL != m_pTObject)
return m_pTObject;
throw runtime_error( " accessthroughNULLpointr " );
}
// *重载
T & operator * ()
{
if (NULL != m_pTObject)
return * m_pTObject;
throw runtime_error( " dereferenceofNULLpointer " );
}
const T & operator * () const
{
if (NULL != m_pTObject)
return & m_pTObject;
throw runtime_error( " dereferenceofNULLpointer " );
}
private :
// 引用计数减1
void DoDecUseCount( void )
{
if ( 0 == --* m_pCount)
{
if (NULL != m_pTObject)
{
deletem_pTObject;
m_pTObject = NULL;
}
deletem_pCount;
m_pCount = NULL;
}
}
T * m_pTObject;
int * m_pCount;
}
//调用

/* ********************************************************************** */
/* *智能指针
/*********************************************************************** */

// SmartPointerStu.cpp:Definestheentrypointfortheconsoleapplication.
//

#include " stdafx.h "

#include " SmartPointer.h "
#include < iostream >
using namespace std;

// 一个测试智能指针的类
class CMyTestClass
{
public :
CMyTestClass(){cout << " ACMyTestClassObjectwascreated. " << endl;}
virtual void Print( void ){cout << " CMyTestClassPrint(). " << endl;}
virtual void Show( void ){cout << " CMyTestClassShow(). " << endl;}
~ CMyTestClass(){cout << " ACMyTestClassObjectwasdestroied. " << endl;}
};

class CMyTestSubClass: public CMyTestClass
{
public :
CMyTestSubClass(){cout << " ACMyTestSubClassObjectwascreated. " << endl;}
virtual void Print( void ){cout << " CMyTestSubClassPrint(). " << endl;}
void SubShow( void ){cout << " SubShow(). " << endl;}
~ CMyTestSubClass(){cout << " ACMyTestSubClassObjectwasdestroied. " << endl;}
};

int _tmain( int argc,_TCHAR * argv[])
{
try
{
TSmartPtr < CMyTestClass > t; // 因为没有给t传个CMyTestClass对象的指针参数进去。所以会出异常。
t -> Print();
}
catch ( const exception & err)
{
cout << err.what() << endl;
}
// 上面这个已经测试通过了。结果正确。
// --------------------------------------
TSmartPtr < CMyTestClass > t1( new CMyTestClass);
t1 -> Print();
// 上面这个测试->重载的操作符的正确性。测试结果是正确的。
TSmartPtr < CMyTestClass > t2(t1);
t2 -> Print();
// 上面这个测试拷贝构造函数的正确性。测试结果是正确的。
TSmartPtr < CMyTestClass > t3( new CMyTestClass);
t3 = t2;
( * t3).Print();
// 上面这个测试=重载的操作符的正确性。测试结果也是正确的。

TSmartPtr < CMyTestSubClass > ts4( new CMyTestSubClass);
ts4 -> Print();
ts4 -> SubShow();
ts4 -> Show();
TSmartPtr < CMyTestSubClass > ts5(ts4);
ts5 -> SubShow();
TSmartPtr < CMyTestSubClass > ts6 = ts5;
ts6 -> Print();
// 上面测试一下带有继承关系的类指针对象的智能指针使用。测试结果也是正确的。

system( " pause " );
return 0 ;
}