Background

估計只要是C++程序員，沒有一個不痛恨這個野指針啦，而對于我們這種只能通過log來debug的程序員來說，其恨更深。

Solution

每次看到形如下面的代碼時

A* p1 = new A;

A* p2 = p1;

…

delete p1;

我都有一種想要將p2也置成空的沖動,但往往都不遂我心愿，因為在實際中p1,p2的出現實在是神出鬼沒，讓你防不勝防也煩不勝煩。

魯迅先生說過: 不在沉默中暴發就在沉默中滅亡。幸好，我沒有滅亡，所以我要暴發。

在防夠了，煩飽了以后，我下定決心，要端掉這個讓我受盡折磨地暗堡。

復雜問題的解決方案往往都是簡單而“暴力”地，因為問題的難解決一般來說都是因為”暴力”無處著力。我堅信這個規則，所以我的思路很簡單，就是要在delete p1的時候把p2也置為空。

計算機科學中有個神話般的格言：計算機科學中的大部分問題都可以通過增加一個中間層來解決。我希望這一次神話能得以延續。

好了，想想吧，我們要解決的問題實際上只有一個，那就是要找一個機制，讓p2能知悉它所指向對象的狀態（在這里是生命周期）。如果我們把A的生命周期作為一個類提出來，把它叫LifeObject吧，并給每個A的實例一個配備一個LifeObject對象，再讓p1和p2指向這個生命周期對象，這樣我們只須在A的構造函數中創建一個LifeObject對象，在析構函數中將告訴LifeObject，這樣在使用p1和p2的時候就知道當前使用的指針是否是有效的啦。

其關系示意如下:

Implement

思路有了，就像有了作戰計劃，那當然要開始行軍了：

那個示意圖告訴了我們致少4件事：

1. p1,p2現在不能是指向A的裸指針啦，因為一個裸指針無法自己做到從LifeObject中獲取相應的信息。需要封裝一下，就叫SafePtr吧；
2. SafePtr要提供銷毀A的方法，取名為Destroy;
3. LifeObject是有引用計數的，因為它要負責在A銷毀之后，通知p1,p2,…pn，同時它還必須是創建在heap上的；
4. LifeObject中要有A的狀態信息，在A構造函數中新建LifeObject時將其狀態信息置為valid，在A析構時置為invalid。

最后，其結構圖大致如下：

從這個結構圖上，我們可以看到：

1. LifeObject是用SafeObject的一個指針m_pPointee來指示SafeObject的狀態的，在SafeObject創建時把自己的地址賦給m_pPointee，在析構時將m_pPointee設為NULL;
2. 通過將LifeObject的析構函數設為私有，并提供銷毀方法Destroy，可以保證它只能在heap上創建，同時除了它的friend SafeObject以外沒有人能創建它。
3. SafePtr提供了判空函數IsNUll和NotNull;

在具體實現的時候，還要考慮的問題是SafePtr要像裸指針一樣，能夠從SafePtr<Derived>轉化為SafePtr<Base>以及從SafePtr<Base> 安全轉換到SafePtr<Derived>一些事。大家可以參見其源碼

/* * SmartPointer.h * * Created on: 2010-9-3 * Author: li_shugan@126.com */ #ifndef SAFEPTR_H_ #define SAFEPTR_H_ #include "SafeObject.h" template<typename ReferenceType> class SafePtr { public: explicit SafePtr(ReferenceType* pPointer); //SafePtr(SafePtr& other); template<typename NewType> SafePtr(SafePtr<NewType>& other); //const SafePtr& operator = (SafePtr& other); template<typename NewType> const SafePtr& operator = (SafePtr<NewType>& other); ~SafePtr(); public: ReferenceType* operator->()const; ReferenceType& operator*()const; void Destroy(void); bool IsNull(void); bool NotNull(void); template<typename NewType> operator SafePtr<NewType>() { return SafePtr<NewType>(r_pValue); } template<typename NewType> SafePtr<NewType> Cast() { return SafePtr<NewType>(dynamic_cast<NewType*>(r_pValue)); } private: void Init(void); private: ReferenceType* r_pValue; LifeObject* r_pRefObj; template<class NewType> friend class SafePtr; }; #include "SafePtr.inl" #endif /* SMARTPOINTER_H_ */

/* * SmartPointer.inl * * Created on: 2010-9-3 * Author: li_shugan@126.com */ #include <cstddef> template<typename ReferenceType> SafePtr<ReferenceType>::SafePtr(ReferenceType* pPointer): r_pValue(pPointer), r_pRefObj(NULL) { if(NULL != pPointer) { r_pRefObj = pPointer->GetCountObj(); r_pRefObj->AddRef(); } } template<typename ReferenceType> SafePtr<ReferenceType>::~SafePtr() { if(NULL != r_pRefObj) { r_pRefObj->Release(); } } //template<typename ReferenceType> //SafePtr<ReferenceType>::SafePtr(SafePtr<ReferenceType>& other): // r_pValue(other.r_pValue), // r_pRefObj(other.r_pRefObj) //{ // Init(); //} template<typename ReferenceType> template<typename NewType> SafePtr<ReferenceType>::SafePtr(SafePtr<NewType>& other): r_pValue(other.r_pValue), r_pRefObj(other.r_pRefObj) { Init(); } template<typename ReferenceType> template<typename NewType> const SafePtr<ReferenceType>& SafePtr<ReferenceType>::operator = (SafePtr<NewType>& other) { if(r_pRefObj != other.r_pRefObj) { LifeObject* oldPtr = r_pRefObj; r_pValue = other.pPointer; r_pRefObj = other.r_pRefObj; Init(); if(NULL != oldPtr) { oldPtr->Release(); } } return *this; } template<typename ReferenceType> void SafePtr<ReferenceType>::Init(void) { if(NotNull()) { r_pRefObj->AddRef(); } else { r_pValue = NULL; r_pRefObj = NULL; } } template<typename ReferenceType> ReferenceType* SafePtr<ReferenceType>::operator->()const { return r_pValue; } template<typename ReferenceType> ReferenceType& SafePtr<ReferenceType>::operator*()const { return *r_pValue; } template<typename ReferenceType> void SafePtr<ReferenceType>::Destroy(void) { if(NULL != r_pRefObj) { r_pRefObj->Destroy(); r_pRefObj->Release(); r_pValue = NULL; r_pRefObj = NULL; } } template<typename ReferenceType> bool SafePtr<ReferenceType>::IsNull(void) { return (NULL == r_pRefObj) || !r_pRefObj->IsValid(); } template<typename ReferenceType> bool SafePtr<ReferenceType>::NotNull(void) { return !IsNull(); }

/* * SafeObject.h * * Created on: 2010-9-4 * Author: li_shugan@126.com */ #ifndef SAFEOBJECT_H_ #define SAFEOBJECT_H_ class SafeObject; class LifeObject { public: explicit LifeObject(SafeObject *pPointee); void Destroy(void); int AddRef(void); int Release(void); bool IsValid(void){return 0 != r_pPointee;} private: //You should always create the instance of LifeObject in heap. ~LifeObject(){}; //can not been copy or assignment. LifeObject(const LifeObject& other); LifeObject& operator = (const LifeObject& other); private: int m_nRefCount; SafeObject* r_pPointee; friend class SafeObject; }; class SafeObject { public: SafeObject(); virtual ~SafeObject() = 0; LifeObject* GetCountObj(void)const{return m_pLifeObject;} int test(){return 2;} private: LifeObject* m_pLifeObject; }; #endif /* SAFEOBJECT_H_ */

/* * SafeObject.cpp * * Created on: 2010-9-4 * Author: li_shugan@126.com */ #include <cstddef> #include "SafeObject.h" LifeObject::LifeObject(SafeObject *pPointee): m_nRefCount(0), r_pPointee(pPointee) { } void LifeObject::Destroy(void) { delete r_pPointee; } int LifeObject::AddRef(void) { return ++m_nRefCount; } int LifeObject::Release(void) { if(0 == (--m_nRefCount)) { delete this; } return m_nRefCount; } SafeObject::SafeObject() { // TODO Auto-generated constructor stub m_pLifeObject = new LifeObject(this); } SafeObject::~SafeObject() { m_pLifeObject->r_pPointee = NULL; }

How to use it?

1. 首先你要讓你的類繼承處SafeObject，如下：

class Test: public SafeObject

1. 像使用智能指針一樣使用它

SafePtr<Test> pp(new Test);

SafePtr<Test> pp1 = pp;

if(pp1.NotNull())

{

pp1->output();

pp1->Fun();

SafePtr<SafeObject> pp3(pp);

cout<<pp3->test()<<endl;

}

pp.Destroy();

if(pp1.NotNull())

{

pp1->Fun();

}

Test Code如下:

        

          /*
 * main.cpp
 *
 *  Created on: 2010-9-4
 *      Author: Administrator
 */
#include "SafePtr.h"
#include "SafeObject.h"
#include <iostream>
using std::cout;
using std::endl;
class Base1
{
public:
	void output()
	{
		cout<<__FUNCTION__<<endl;
	}
};
class Test:public Base1,public SafeObject
{
public:
	~Test()
	{
		cout<<__FUNCTION__<<endl;
	}
public:
	void Fun(void)
	{
		cout<<"You invoke fun"<<endl;
	}
};
#include <memory>
int main(int argc,char** argv)
{
	SafePtr<Test> pp(new Test);
	SafePtr<Test> pp1 = pp;
	if(pp1.NotNull())
	{
		pp1->output();
		pp1->Fun();

		SafePtr<SafeObject> pp3(pp);
		cout<<pp3->test()<<endl;
	}
	pp.Destroy();
	if(pp1.NotNull())
	{
		pp1->Fun();
	}

	SafePtr<Test> pp4 = pp;
	if(pp4.NotNull())
	{
		pp4->Fun();
	}

	SafePtr<Test> pp5 = pp1;
	if(pp5.NotNull())
	{
		pp4->Fun();
	}

	return 0;
}
          

        
        

      

Advantage

我想大家已經看出來了，接口的定義和智能指針很相似，只是多了一個Destroy函數而已，所以它的優點就有兩個啦：

1. 野指針在這兒灰飛煙滅了;
2. 如果不調用destroy函數，它就是一智能指針，用它可以防止內存泄漏。

Disadvantage

雖然它解決了C++中兩大問題，但是它的缺點也是有目共睹的，除了常規智能指針的缺陷外它還多出了兩個：

1. 不能調用delete來銷毀一個指針，你要通通換成對Destroy函數的的調用;
2. 如果你想要享受特權公民的待遇，你就得讓你的類從SafeObject繼承一下。

珍愛生命，遠離野指針