引用计数的智能指针的实现

引用计数的智能指针是对《Effective C++ 条款13：以对象管理资源》的一个实现。

我们要设计一个智能指针，使他能够管理资源，在正确的实际调用资源的析构函数。

首先我们需要一个指针reference来指向资源，当智能指针构造时，用reference指针指向资源，在我们确定资源应该被析构时，我们对reference指针进行delete。

如果只有reference指针的话，只能实现出auto_ptr的效果，我们还需要添加引用计数系统counter来统计指向资源的智能指针的个数。counter不可以是一个普通的int型变量，因为不同的智能指针可能会有相同的计数，也不可以是一个static变量，因为同时存在的智能指针可以指向不同的资源，也就拥有不同的引用计数。因此将counter设计成一个指向int的指针，指向相同资源的智能指针的counter也指向相同的int值，这样对counter做修改时，就会影响到所有拥有这个counter的智能指针。

我们的智能指针还应该能实现多态的效果，因此指向同一个资源的智能指针中的reference指针可能有不同的类型。然而这就给我们的析构过程带来了困扰，我们在析构资源的时候需要知道资源原始的类型与指针，因此我们用一个指向void*的指针originalReference来保存原始的指针。

有了指向原始资源的指针，我们还需要原始资源的类型才能正常delete，我们在每个资源创建出来时，提供一个指向特殊的销毁函数的指针originalDestructor，保证这个函数能够成功的销毁资源。

有了这些成员变量我们就可以实现出一个简单的引用计数的智能指针。可见智能指针占用的空间要比普通指针大数倍。

按照《条款14：在资源管理类中小心copying行为》，仔细的为智能指针添加copying行为。

最后适当的重载操作符，使智能指针能够像一个普通指针那样使用。

  1 namespace cylib {
  2     
  3     // 引用计数操作器
  4     template<typename T> struct ReferenceCounterOperator
  5     {
  6         // 返回一个引用计数器
  7         static int* CreateCounter(T* reference)
  8         {
  9             return new int(0);
 10 
 11         }
 12         // 删除引用函数
 13         static void DeleteReference(int* counter, void* reference)
 14         {
 15             delete counter;// 删除计数器
 16             delete (T*)reference;// 删除资源
 17         }
 18     };
 19 
 20     
 21     // 智能指针类
 22     template<typename T> class SmartPtr
 23     {
 24     private:
 25         template<typename X> friend class SmartPtr;
 26         // 删除器
 27         typedef void (*Destructor)(int*, void*);
 28         // 引用计数器
 29         int* counter;
 30         // 引用资源，在拷贝过程中可能改变类型
 31         T* reference;
 32         // 原始引用资源，保持资源第一次创建时的指针
 33         void* originalReference;
 34         // 原始资源删除函数，在最后一个引用被析构时调用，删除资源
 35         Destructor originalDestructor;
 36 
 37         // 增加引用计数
 38         void Inc()
 39         {
 40             if (counter)
 41             {
 42                 ++(*counter);
 43             }
 44         }
 45         // 减少引用计数，如果资源不再被引用则删除资源
 46         void Dec()
 47         {
 48             if (counter)
 49             {
 50                 if (--(*counter) == 0)
 51                 {
 52                     originalDestructor(counter, originalReference);
 53                     counter = 0;
 54                     reference = 0;
 55                     originalReference = 0;
 56                     originalDestructor = 0;
 57                 }
 58             }
 59         }
 60 
 61         // 返回当前计数器
 62         int* Counter() const
 63         {
 64             return counter;
 65         }
 66 
 67         // 私有构造器
 68         SmartPtr(int* _counter, T* _reference, void* _originalReference, Destructor _originalDestructor)
 69             : counter(_counter)
 70             , reference(_reference)
 71             , originalReference(_originalReference)
 72             , originalDestructor(_originalDestructor)
 73         {
 74             Inc();
 75         }
 76 
 77     public:
 78         // 获取资源的直接指针
 79         T* get() const
 80         {
 81             return reference;
 82         }
 83         // 重载->操作符
 84         T* operator->()const
 85         {
 86             return reference;
 87         }
 88         // 重载*操作符，危险！
 89         T& operator*() const {
 90             return *reference;
 91         }
 92 
 93         // 构造一个空的智能指针，不指向任何资源
 94         SmartPtr()
 95             : counter(0)
 96             , reference(0)
 97             , originalReference(0)
 98             , originalDestructor(0)
 99         {}
100         // 用一个普通指针构造智能指针，是最基本的用法
101         SmartPtr(T* pointer)
102             : counter(0)
103             , reference(0)
104             , originalReference(0)
105             , originalDestructor(0)
106         {
107             if (pointer)
108             {
109                 counter = ReferenceCounterOperator<T>::CreateCounter(pointer);// 创建新的计数器
110                 reference = pointer;// 获取当前资源的引用
111                 originalReference = pointer;// 将原始资源置为当前资源
112                 originalDestructor = ReferenceCounterOperator<T>::DeleteReference;// 连接删除器
113                 Inc();// 引用计数增加
114             }
115         };
116         // 用另一个同类型的智能指针进行拷贝构造，不创建新资源
117         SmartPtr(const SmartPtr<T>& pointer)
118             : counter(pointer.counter)
119             , reference(pointer.reference)
120             , originalReference(pointer.originalReference)
121             , originalDestructor(pointer.originalDestructor)
122         {
123             Inc();// 引用计数增加
124         }
125         // 用其他类型的智能指针进行转型拷贝构造，不创建新资源
126         // 将原始类型U转换为当前智能指针的类型T，但是原始资源与原始删除器不变
127         template<typename U> SmartPtr(const SmartPtr<U>& pointer)
128             : counter(0)
129             , reference(0)
130             , originalReference(0)
131             , originalDestructor(0)
132         {
133             T* converted = pointer.get();
134             if (converted)
135             {
136                 counter = pointer.Counter();
137                 reference = converted;
138                 originalReference = pointer.originalReference;
139                 originalDestructor = pointer.originalDestructor;
140                 Inc();
141             }
142         }
143 
144         // 析构当前的智能指针，减少引用计数
145         ~SmartPtr()
146         {
147             Dec();
148         }
149 
150         // 将一个普通指针的值赋给智能指针
151         // 智能指针之前引用的资源取消，由普通指针构造出新的智能指针
152         // 构造失败则将智能指针置为空
153         SmartPtr<T>& operator=(T* pointer)
154         {
155             Dec();// 原本的资源引用减少
156             if (pointer)
157             {
158                 counter = ReferenceCounterOperator<T>::CreateCounter(pointer);
159                 reference = pointer;
160                 originalReference = pointer;
161                 originalDestructor = &ReferenceCounterOperator<T>::DeleteReference;
162                 Inc();
163             }
164             else
165             {
166                 counter = 0;
167                 reference = 0;
168                 originalReference = 0;
169                 originalDestructor = 0;
170             }
171             return *this;
172         }
173         // 将另一个智能指针的值赋给自身
174         // 智能指针之前引用的资源取消，并引用新的智能指针的资源
175         SmartPtr<T>& operator=(const SmartPtr<T>& pointer)
176         {
177             if (this != &pointer)// 判断是否自赋值
178             {
179                 Dec();
180                 counter = pointer.counter;
181                 reference = pointer.reference;
182                 originalReference = pointer.originalReference;
183                 originalDestructor = pointer.originalDestructor;
184                 Inc();
185             }
186             return *this;
187         }
188         // 将一个不同类型的智能指针赋给自身
189         // 智能指针之前引用的资源取消，并引用新的智能指针的资源
190         // 转型失败的话返回空智能指针
191         template<typename U> SmartPtr<T>& operator=(const SmartPtr<U>& pointer)
192         {
193             T* converted = pointer.get();
194             Dec();
195             if (converted)
196             {
197                 counter = pointer.counter;
198                 reference = converted;
199                 originalReference = pointer.originalReference;
200                 originalDestructor = pointer.originalDestructor;
201                 Inc();
202             }
203             else
204             {
205                 counter = 0;
206                 reference = 0;
207                 originalReference = 0;
208                 originalDestructor = 0;
209             }
210             return *this;
211         }
212 
213         // 重载比较操作符，用于比较智能指针与普通指针是否指向相同资源
214         bool operator==(const T* pointer)const { return reference == pointer; }
215         bool operator!=(const T* pointer)const { return reference != pointer; }
216         bool operator>(const T* pointer)const { return reference>pointer; }
217         bool operator>=(const T* pointer)const { return reference >= pointer; }
218         bool operator<(const T* pointer)const { return reference<pointer; }
219         bool operator<=(const T* pointer)const { return reference <= pointer; }
220 
221         // 重载比较操作符，用于比较两个智能指针是否指向相同资源
222         bool operator==(const SmartPtr<T>& pointer)const { return reference == pointer.reference; }
223         bool operator!=(const SmartPtr<T>& pointer)const { return reference != pointer.reference; }
224         bool operator>(const SmartPtr<T>& pointer)const { return reference>pointer.reference; }
225         bool operator>=(const SmartPtr<T>& pointer)const { return reference >= pointer.reference; }
226         bool operator<(const SmartPtr<T>& pointer)const { return reference<pointer.reference; }
227         bool operator<=(const SmartPtr<T>& pointer)const { return reference <= pointer.reference; }
228 
229         // 智能指针指向非空时有true的布尔值
230         operator bool()const{ return reference != 0; }
231 
232     };
233     
234 }

测试代码：

 1 #include <iostream>
 2 #include "SmartPoint.h"
 3 using namespace std;
 4 
 5 class B {
 6 public:
 7     B() { cout << "构造了一个基类~" << endl; }
 8     virtual ~B() { cout << "基类被析构啦!" << endl; }
 9     virtual void message() { cout << "基基基基基基基基基基基基" << endl; }
10 };
11 
12 class D : public B {
13 public:
14     D() { cout << "构造了一个派生类~" << endl; }
15     virtual ~D() { cout << "派生类被析构啦!" << endl; }
16     virtual void message() { cout << "派派派派派派派派派派派派" << endl; }
17 };
18 
19 void test1() { 
20     cout << "构造演示:" << endl;
21     cylib::SmartPtr<B> bp = new B();
22     cylib::SmartPtr<B> bp2(new B());
23 }
24 void test2() { 
25     cout << "比较演示:" << endl;
26     cylib::SmartPtr<B> bp = new B();
27     B* p = bp.get();
28     cylib::SmartPtr<B> bp2 = bp;
29     if (bp == p) cout << "相等" << endl;
30     if (bp == bp2) cout << "相等" << endl;
31 }
32 void test3() {
33     cout << "多态演示:" << endl;
34     cylib::SmartPtr<B> bp;
35     cylib::SmartPtr<D> dp = new D();
36     bp = dp;
37     bp->message();
38 }
39 
40 
41 int main()
42 {
43     cout << "---------------" << endl;
44     test1();
45     cout << "---------------" << endl;
46     test2();
47     cout << "---------------" << endl;
48     test3();
49     cout << "---------------" << endl;
50     system("pause");
51 
52 }

测试结果：

 1 ---------------
 2 构造演示:
 3 构造了一个基类~
 4 构造了一个基类~
 5 基类被析构啦!
 6 基类被析构啦!
 7 ---------------
 8 比较演示:
 9 构造了一个基类~
10 相等
11 相等
12 基类被析构啦!
13 ---------------
14 多态演示:
15 构造了一个基类~
16 构造了一个派生类~
17 派派派派派派派派派派派派
18 派生类被析构啦!
19 基类被析构啦!
20 ---------------
21 请按任意键继续. . .