智能指针

  1 namespace smart
  2 {
  3     // 引用计数类.
  4      class smart_count
  5     {
  6     public:
  7         smart_count(int c = 0) : use_count(c) {}
  8         ~smart_count() {}
  9 
 10         // 增加引用计数, 并返回计数值.
 11         int addref() { return ++use_count; }
 12         // 减少引用计数, 并返回计数值.
 13         int release() { return --use_count; }
 14 
 15     private:
 16         // 计数变量.
 17         int use_count;
 18     };
 19 
 20     // 智能指针.
 21     template <class T>
 22     class smart_ptr
 23     {
 24     public:
 25         // 构造指针, 并使引用计数置为1.
 26         explicit smart_ptr (T* ptr) : p(ptr), u(new smart_count(1))
 27         {}
 28 
 29         // 构造空指针.
 30         explicit smart_ptr () : p(NULL), u(NULL)
 31         {}
 32 
 33         // 智能指针析构.
 34         ~smart_ptr (void)
 35         {
 36             // 如果引用计数等于0, 则删除数据和引用计数, 并置p为NULL.
 37             // 此处需要注意的是, 共用的u并未置为 NULL, 在其它指针析构
 38             // 时, p为NULL, 则不会重复delete.
 39             if (p && u->release() <= 0)
 40             {
 41                 delete p;
 42                 delete u;
 43                 p = NULL;
 44             }        
 45         }
 46 
 47         // 智能指针拷贝构造函数.
 48         smart_ptr (const smart_ptr<T>& t)
 49         {
 50             p = t.p;
 51             u = t.u;
 52 
 53             if (u) // 必须判断空值.
 54             {
 55                 u->addref();    // 增加引用计数.
 56             }
 57         }
 58 
 59         // 指针赋值.
 60         void operator= (smart_ptr<T>& t)
 61         {
 62             // 首先将引用计数减1, 然后再判断是否小于0, 如果小于0, 则delete.            
 63             if (p && u->release() <= 0)
 64             {
 65                 delete p;
 66                 delete u;
 67             }
 68 
 69             // 直接赋值.
 70             p = t.p;
 71             u = t.u;
 72 
 73             if (u)    // 必须判断空值.
 74             {
 75                 u->addref(); // 增加引用计数.
 76             }
 77         }
 78 
 79         // 重载->操作和*操作符.
 80         T *operator-> (void) { return p; }
 81         T& operator *(void) { return *p; }
 82         // 重载!操作符.
 83         bool operator! () const { return !p;}
 84 
 85         // 重载指针bool值操作符.
 86         typedef smart_ptr<T> this_type;
 87         typedef T * this_type::*unspecified_bool_type;
 88         operator unspecified_bool_type() const { return !p ? 0: &this_type::p; }
 89         // 得到原指针.
 90         T* get() { return p; }
 91         void reset(T* ptr)
 92         {
 93             // 首先将引用计数减1, 然后再判断是否小于0, 如果小于0, 则delete.            
 94             if (p && u->release() <= 0)
 95             {
 96                 delete p;
 97                 delete u;
 98             }
 99 
100             // 赋值, 如果是NULL, 则不创建引用计数.
101             p = ptr;
102             if (p)
103                 u = new smart_count(1);
104             else
105                 u = NULL;
106         }
107 
108         void reset(smart_ptr<T>& t)
109         {
110             // 首先将引用计数减1, 然后再判断是否小于0, 如果小于0, 则delete.            
111             if (p && u->release() <= 0)
112             {
113                 delete p;
114                 delete u;
115             }
116 
117             // 赋值.
118             p = t.p;
119             u = t.u;
120 
121             if (u)    // 必须判断空值.
122             {
123                 u->addref(); // 增加引用计数.
124             }
125         }
126 
127     private:
128         T* p;
129         smart_count* u;
130     };
131 
132     // 重载==操作符.
133     template<class T, class U> inline bool operator==(smart_ptr<T> & a, smart_ptr<U> & b)
134     {
135         return a.get() == b.get();
136     }
137 
138     // 重载!=操作符.
139     template<class T, class U> inline bool operator!=(smart_ptr<T> & a, smart_ptr<U> & b)
140     {
141         return a.get() != b.get();
142     }
143 }