珍爱生命，远离野指针
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件事：
- p1,p2现在不能是指向A的裸指针啦，因为一个裸指针无法自己做到从LifeObject中获取相应的信息。需要封装一下，就叫SafePtr吧；
- SafePtr要提供销毁A的方法，取名为Destroy;
- LifeObject是有引用计数的，因为它要负责在A销毁之后，通知p1,p2,…pn，同时它还必须是创建在heap上的；
- LifeObject中要有A的状态信息，在A构造函数中新建LifeObject时将其状态信息置为valid，在A析构时置为invalid。
最后，其结构图大致如下：
从这个结构图上，我们可以看到：
- LifeObject是用SafeObject的一个指针m_pPointee来指示SafeObject的状态的，在SafeObject创建时把自己的地址赋给m_pPointee，在析构时将m_pPointee设为NULL;
- 通过将LifeObject的析构函数设为私有，并提供销毁方法Destroy，可以保证它只能在heap上创建，同时除了它的friend SafeObject以外没有人能创建它。
- SafePtr提供了判空函数IsNUll和NotNull;
在具体实现的时候，还要考虑的问题是SafePtr要像裸指针一样，能够从SafePtr<Derived>转化为SafePtr<Base>以及从SafePtr<Base> 安全转换到SafePtr<Derived>一些事。大家可以参见其源码
代码
1 /*
2 * SmartPointer.h
3 *
4 * Created on: 2010-9-3
5 * Author: li_shugan@126.com
6 */
7
8 #ifndef SAFEPTR_H_
9 #define SAFEPTR_H_
10 #include "SafeObject.h"
11 template<typename ReferenceType>
12 class SafePtr {
13 public:
14 explicit SafePtr(ReferenceType* pPointer);
15 //SafePtr(SafePtr& other);
16
17 template<typename NewType>
18 SafePtr(SafePtr<NewType>& other);
19
20 //const SafePtr& operator = (SafePtr& other);
21
22 template<typename NewType>
23 const SafePtr& operator = (SafePtr<NewType>& other);
24
25 ~SafePtr();
26 public:
27 ReferenceType* operator->()const;
28 ReferenceType& operator*()const;
29 void Destroy(void);
30 bool IsNull(void);
31 bool NotNull(void);
32
33
34 template<typename NewType>
35 operator SafePtr<NewType>()
36 {
37 return SafePtr<NewType>(r_pValue);
38 }
39
40 template<typename NewType>
41 SafePtr<NewType> Cast()
42 {
43 return SafePtr<NewType>(dynamic_cast<NewType*>(r_pValue));
44 }
45
46 private:
47 void Init(void);
48 private:
49 ReferenceType* r_pValue;
50 LifeObject* r_pRefObj;
51
52 template<class NewType>
53 friend class SafePtr;
54 };
55 #include "SafePtr.inl"
56 #endif /* SMARTPOINTER_H_ */
57
代码
1 /*
2 * SmartPointer.inl
3 *
4 * Created on: 2010-9-3
5 * Author: li_shugan@126.com
6 */
7 #include <cstddef>
8
9 template<typename ReferenceType>
10 SafePtr<ReferenceType>::SafePtr(ReferenceType* pPointer):
11 r_pValue(pPointer),
12 r_pRefObj(NULL)
13 {
14 if(NULL != pPointer)
15 {
16 r_pRefObj = pPointer->GetCountObj();
17 r_pRefObj->AddRef();
18 }
19 }
20
21 template<typename ReferenceType>
22 SafePtr<ReferenceType>::~SafePtr()
23 {
24 if(NULL != r_pRefObj)
25 {
26 r_pRefObj->Release();
27 }
28 }
29
30 //template<typename ReferenceType>
31 //SafePtr<ReferenceType>::SafePtr(SafePtr<ReferenceType>& other):
32 // r_pValue(other.r_pValue),
33 // r_pRefObj(other.r_pRefObj)
34 //{
35 // Init();
36 //}
37
38 template<typename ReferenceType>
39 template<typename NewType>
40 SafePtr<ReferenceType>::SafePtr(SafePtr<NewType>& other):
41 r_pValue(other.r_pValue),
42 r_pRefObj(other.r_pRefObj)
43 {
44 Init();
45 }
46
47 template<typename ReferenceType>
48 template<typename NewType>
49 const SafePtr<ReferenceType>& SafePtr<ReferenceType>::operator = (SafePtr<NewType>& other)
50 {
51 if(r_pRefObj != other.r_pRefObj)
52 {
53 LifeObject* oldPtr = r_pRefObj;
54
55 r_pValue = other.pPointer;
56 r_pRefObj = other.r_pRefObj;
57 Init();
58
59 if(NULL != oldPtr)
60 {
61 oldPtr->Release();
62 }
63 }
64 return *this;
65 }
66
67 template<typename ReferenceType>
68 void SafePtr<ReferenceType>::Init(void)
69 {
70 if(NotNull())
71 {
72 r_pRefObj->AddRef();
73 }
74 else
75 {
76 r_pValue = NULL;
77 r_pRefObj = NULL;
78 }
79
80 }
81
82 template<typename ReferenceType>
83 ReferenceType* SafePtr<ReferenceType>::operator->()const
84 {
85 return r_pValue;
86 }
87
88 template<typename ReferenceType>
89 ReferenceType& SafePtr<ReferenceType>::operator*()const
90 {
91 return *r_pValue;
92 }
93
94 template<typename ReferenceType>
95 void SafePtr<ReferenceType>::Destroy(void)
96 {
97 if(NULL != r_pRefObj)
98 {
99 r_pRefObj->Destroy();
100 r_pRefObj->Release();
101 r_pValue = NULL;
102 r_pRefObj = NULL;
103 }
104 }
105
106 template<typename ReferenceType>
107 bool SafePtr<ReferenceType>::IsNull(void)
108 {
109 return (NULL == r_pRefObj) || !r_pRefObj->IsValid();
110 }
111
112 template<typename ReferenceType>
113 bool SafePtr<ReferenceType>::NotNull(void)
114 {
115 return !IsNull();
116 }
117
代码
1 /*
2 * SafeObject.h
3 *
4 * Created on: 2010-9-4
5 * Author: li_shugan@126.com
6 */
7
8 #ifndef SAFEOBJECT_H_
9 #define SAFEOBJECT_H_
10
11 class SafeObject;
12 class LifeObject
13 {
14 public:
15 explicit LifeObject(SafeObject *pPointee);
16 void Destroy(void);
17 int AddRef(void);
18 int Release(void);
19 bool IsValid(void){return 0 != r_pPointee;}
20 private:
21 //You should always create the instance of LifeObject in heap.
22 ~LifeObject(){};
23
24 //can not been copy or assignment.
25 LifeObject(const LifeObject& other);
26 LifeObject& operator = (const LifeObject& other);
27 private:
28 int m_nRefCount;
29 SafeObject* r_pPointee;
30 friend class SafeObject;
31 };
32
33 class SafeObject {
34 public:
35 SafeObject();
36 virtual ~SafeObject() = 0;
37 LifeObject* GetCountObj(void)const{return m_pLifeObject;}
38 int test(){return 2;}
39 private:
40 LifeObject* m_pLifeObject;
41 };
42 #endif /* SAFEOBJECT_H_ */
43
代码
1 /*
2 * SafeObject.cpp
3 *
4 * Created on: 2010-9-4
5 * Author: li_shugan@126.com
6 */
7 #include <cstddef>
8 #include "SafeObject.h"
9
10 LifeObject::LifeObject(SafeObject *pPointee):
11 m_nRefCount(0),
12 r_pPointee(pPointee)
13 {
14 }
15
16
17 void LifeObject::Destroy(void)
18 {
19 delete r_pPointee;
20 }
21
22
23 int LifeObject::AddRef(void)
24 {
25 return ++m_nRefCount;
26 }
27
28
29 int LifeObject::Release(void)
30 {
31 if(0 == (--m_nRefCount))
32 {
33 delete this;
34 }
35 return m_nRefCount;
36 }
37
38
39
40 SafeObject::SafeObject() {
41 // TODO Auto-generated constructor stub
42 m_pLifeObject = new LifeObject(this);
43 }
44
45
46 SafeObject::~SafeObject() {
47 m_pLifeObject->r_pPointee = NULL;
48 }
49
How to use it?
- 首先你要让你的类继承处SafeObject，如下：
class Test: public SafeObject
- 像使用智能指针一样使用它
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如下:
代码
1 /*
2 * main.cpp
3 *
4 * Created on: 2010-9-4
5 * Author: Administrator
6 */
7 #include "SafePtr.h"
8 #include "SafeObject.h"
9 #include <iostream>
10 using std::cout;
11 using std::endl;
12 class Base1
13 {
14 public:
15 void output()
16 {
17 cout<<__FUNCTION__<<endl;
18 }
19 };
20 class Test:public Base1,public SafeObject
21 {
22 public:
23 ~Test()
24 {
25 cout<<__FUNCTION__<<endl;
26 }
27 public:
28 void Fun(void)
29 {
30 cout<<"You invoke fun"<<endl;
31 }
32 };
33 #include <memory>
34 int main(int argc,char** argv)
35 {
36 SafePtr<Test> pp(new Test);
37 SafePtr<Test> pp1 = pp;
38 if(pp1.NotNull())
39 {
40 pp1->output();
41 pp1->Fun();
42
43 SafePtr<SafeObject> pp3(pp);
44 cout<<pp3->test()<<endl;
45 }
46 pp.Destroy();
47 if(pp1.NotNull())
48 {
49 pp1->Fun();
50 }
51
52 SafePtr<Test> pp4 = pp;
53 if(pp4.NotNull())
54 {
55 pp4->Fun();
56 }
57
58 SafePtr<Test> pp5 = pp1;
59 if(pp5.NotNull())
60 {
61 pp4->Fun();
62 }
63
64 return 0;
65 }
66
Advantage
我想大家已经看出来了，接口的定义和智能指针很相似，只是多了一个Destroy函数而已，所以它的优点就有两个啦：
- 野指针在这儿灰飞烟灭了;
- 如果不调用destroy函数，它就是一智能指针，用它可以防止内存泄漏。
Disadvantage
虽然它解决了C++中两大问题，但是它的缺点也是有目共睹的，除了常规智能指针的缺陷外它还多出了两个：
- 不能调用delete来销毁一个指针，你要通通换成对Destroy函数的的调用;
- 如果你想要享受特权公民的待遇，你就得让你的类从SafeObject继承一下。
