一个简单smart pointer的实现

转自出处

　　学习这个代码有助于理解shared_ptr指针的实现方法
　　smart.cpp
　　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 }