1 template <typename T>
 2 class SmartPointer {
 3 public:
 4     //构造函数
 5     SmartPointer(T* p=0): _ptr(p), _reference_count(new size_t){
 6         if(p)
 7             *_reference_count = 1;
 8         else
 9             *_reference_count = 0;
10     }
11     //拷贝构造函数
12     SmartPointer(const SmartPointer& src) {
13         if(this!=&src) {
14             _ptr = src._ptr;
15             _reference_count = src._reference_count;
16             (*_reference_count)++;
17         }
18     }
19     //重载赋值操作符
20     SmartPointer& operator=(const SmartPointer& src) {
21         if(_ptr==src._ptr) {
22             return *this;
23         }
24         releaseCount();
25         _ptr = src._ptr;
26         _reference_count = src._reference_count;
27         (*_reference_count)++;
28         return *this;
29     }
30
31     //重载操作符
32     T& operator*() {
33         if(ptr) {
34             return *_ptr;
35         }
36         //throw exception
37     }
38     //重载操作符
39     T* operator->() {
40         if(ptr) {
41             return _ptr;
42         }
43         //throw exception
44     }
45     //析构函数
46     ~SmartPointer() {
47         if (--(*_reference_count) == 0) {
48             delete _ptr;
49             delete _reference_count;
50         }
51     }
52 private:
53     T *_ptr;
54         size_t *_reference_count;
55         void releaseCount() {
56         if(_ptr) {
57             (*_reference_count)--;
58                 if((*_reference_count)==0) {
59                     delete _ptr;
60                     delete _reference_count;
61                 }
62         }
63         }
64 };
65
66 int main()
67 {
68     SmartPointer<char> cp1(new char('a'));
69     SmartPointer<char> cp2(cp1);
70     SmartPointer<char> cp3;
71     cp3 = cp2;
72     cp3 = cp1;
73     cp3 = cp3;
74     SmartPointer<char> cp4(new char('b'));
75     cp3 = cp4;
76 }