智能指针

内存泄露一直是C++程序员头疼的问题。下面就简单理解下C++智能指针。

 

智能指针 是存储指向动态分配对象指针的类。 目的是能够自动正确的销毁内存，防止内存泄露。

通

用的实现技术是使用引用计数（reference count），将一个计数器与类指向的对象相关联。引用计数跟踪该类有多少个对象共享同一指针

创建一个类的对象时， 初始化指针并且将引用计数置为1；

当一个对象作为另一个对象的副本而创建时，拷贝构造函数拷贝指针并增加与之相关的引用计数。

对一个对象进行赋值时，赋值操作符减少左操作数的引用计数，如引用计数为0， 删除对象， 释放对象指向的内存

并增加右操作符所指对象的引用计数。

调用析构函数时，减少引用计数， 如果引用计数为0， 删除对象， 释放对象指向的内存

 

设计思路：

由于需要一个引用计数和一个指针动态内存，将他们封装为一个类

 定义一个Uptr类，成员函数为引用计数和指针。 实现构造函数， 析构函数， 拷贝构造函数和赋值运算符重载。

设计一个管理类HasPtr， 管理这个Uptr类的引用计数和指针，将HasPtr声明为Uptr类的友元类。即只有HasPtr可以访问为Uptr类。

用2个类实现的好处是 解耦合，增加智能指针的可扩展性，引用计数和指针是不变的， 智能指针的管理是可变的， 将可变的和不变的逻辑分离出来。

[cpp]  view plain copy

1. class Uptr  
2. {  
3.     /*Uptr has private member, only HasPtr class can access it*/  
4.     friend class HasPtr;      
5.     private:      
6.     Uptr(int *p):m_ptr(p),m_useNum(1)   
7.     {  
8.         cout<< "Uptr constructor called" << endl;  
9.     }  
10.     ~Uptr()   
11.     {  
12.         if(NULL!=m_ptr)   
13.         {  
14.             delete []m_ptr;   
15.             m_ptr = NULL;  
16.         }  
17.         cout << "Uptr destructor called" << endl;  
18.     }  
19.       
20.     Uptr(const Uptr& o)  
21.     {  
22.         m_ptr = o.ptr;  
23.     }  
24.       
25.     Uptr& operator=(const Uptr& o)  
26.     {  
27.         if (&o == this)  
28.         {  
29.             return;  
30.         }  
31.         if (m_ptr != NULL)  
32.         {  
33.             delete []m_ptr;  
34.         }  
35.         //shallow copy  
36.         m_ptr = o.m_ptr;  
37.     }  
38.     private:  
39.         int* m_ptr;  
40.         int m_useNum;  
41.   
42. };  

下面是实现HasPtr 管理类

[cpp]  view plain copy

1. class HasPtr  
2. {  
3.     public:  
4.         HasPtr(int *p):m_ptr(new Uptr(p))   
5.         {  
6.             cout << "HasPtr constructor called!" << "use=" <<  
7.                     m_ptr->m_useNum << endl;  
8.         }  
9.       
10.         HasPtr(const HasPtr& o)  
11.         {     
12.             m_ptr = o.m_ptr;  
13.             /*add the useNum when copy*/  
14.             ++m_ptr->m_useNum;  
15.             cout << "HasPtr copy constructor called!" << "use=" <<  
16.                     m_ptr->m_useNum << endl;  
17.         }  
18.           
19.         HasPtr& operator=(const HasPtr& o);  
20.         ~HasPtr()  
21.         {  
22.             /*delete the useNum when destructor*/  
23.             if (--m_ptr->m_useNum == 0)  
24.             {  
25.                 delete m_ptr;  
26.             }  
27.             cout << "HasPtr distructor called!" << "use=" <<  
28.                     m_ptr->m_useNum << endl;  
29.         }  
30.         void set_ptr(int *p)  
31.         {  
32.             if (p == NULL)  
33.             {  
34.                 delete m_ptr;  
35.             }  
36.             m_ptr->m_ptr = p;  
37.         }  
38.         int* get_ptr() const  
39.         {  
40.             return m_ptr->m_ptr;  
41.         }  
42.   
43.     private:  
44.         Uptr* m_ptr;  
45. };  
46.   
47. HasPtr& HasPtr::operator=(const HasPtr& o)  
48. {  
49.     cout << "operator= called" << endl;  
50.     if (&o == this)  
51.     {  
52.         return *this;  
53.     }  
54.     ++o.m_ptr->m_useNum;  
55.     /*release the memory if it is neccessary*/  
56.     if (--m_ptr->m_useNum == 0)  
57.     {  
58.         delete m_ptr;  
59.     }  
60.     m_ptr = o.m_ptr;  
61.     return *this;  
62. }  

其中有几个需要注意的地方:

赋值运算符重载要考虑 自己赋值给自己的特殊情况， 一个智能指针类对象给另一个智能指针类对象赋值时， 赋值操作符减少左操作数的引用计数，如引用计数为0， 删除对象， 释放对象指向的内存并增加右操作符所指对象的引用计数。

 

全部程序：

[cpp]  view plain copy

1. /* 
2. *describe: realize smart point, keep improve 
3. */  
4. #include <iostream>  
5. #include <string.h>  
6. using namespace std;  
7.   
8. /*use two class realize the function. high cohesion and low coupling*/  
9. class Uptr  
10. {  
11.     /*Uptr has private member, only HasPtr class can access it*/  
12.     friend class HasPtr;      
13.     private:      
14.     Uptr(int *p):m_ptr(p),m_useNum(1)   
15.     {  
16.         cout<< "Uptr constructor called" << endl;  
17.     }  
18.     ~Uptr()   
19.     {  
20.         if(NULL!=m_ptr)   
21.         {  
22.             delete []m_ptr;   
23.             m_ptr = NULL;  
24.         }  
25.         cout << "Uptr destructor called" << endl;  
26.     }  
27.       
28.     Uptr(const Uptr& o)  
29.     {  
30.         m_ptr = o.ptr;  
31.     }  
32.       
33.     Uptr& operator=(const Uptr& o)  
34.     {  
35.         if (&o == this)  
36.         {  
37.             return;  
38.         }  
39.         if (m_ptr != NULL)  
40.         {  
41.             delete []m_ptr;  
42.         }  
43.         //shallow copy  
44.         m_ptr = o.m_ptr;  
45.     }  
46.     private:  
47.         int* m_ptr;  
48.         int m_useNum;  
49.   
50. };  
51.   
52. class HasPtr  
53. {  
54.     public:  
55.         HasPtr(int *p):m_ptr(new Uptr(p))   
56.         {  
57.             cout << "HasPtr constructor called!" << "use=" <<  
58.                     m_ptr->m_useNum << endl;  
59.         }  
60.       
61.         HasPtr(const HasPtr& o)  
62.         {     
63.             m_ptr = o.m_ptr;  
64.             /*add the useNum when copy*/  
65.             ++m_ptr->m_useNum;  
66.             cout << "HasPtr copy constructor called!" << "use=" <<  
67.                     m_ptr->m_useNum << endl;  
68.         }  
69.           
70.         HasPtr& operator=(const HasPtr& o);  
71.         ~HasPtr()  
72.         {  
73.             /*delete the useNum when destructor*/  
74.             if (--m_ptr->m_useNum == 0)  
75.             {  
76.                 delete m_ptr;  
77.             }  
78.             cout << "HasPtr distructor called!" << "use=" <<  
79.                     m_ptr->m_useNum << endl;  
80.         }  
81.         void set_ptr(int *p)  
82.         {  
83.             if (p == NULL)  
84.             {  
85.                 delete m_ptr;  
86.             }  
87.             m_ptr->m_ptr = p;  
88.         }  
89.         int* get_ptr() const  
90.         {  
91.             return m_ptr->m_ptr;  
92.         }  
93.   
94.     private:  
95.         Uptr* m_ptr;  
96. };  
97.   
98. HasPtr& HasPtr::operator=(const HasPtr& o)  
99. {  
100.     cout << "operator= called" << endl;  
101.     if (&o == this)  
102.     {  
103.         return *this;  
104.     }  
105.     ++o.m_ptr->m_useNum;  
106.     /*release the memory if it is neccessary*/  
107.     if (--m_ptr->m_useNum == 0)  
108.     {  
109.         delete m_ptr;  
110.     }  
111.     m_ptr = o.m_ptr;  
112.     return *this;  
113. }  
114.   
115. /*for test*/  
116. void test_func()  
117. {  
118.     int* pValue = new int(10);    
119.     int* pValue1 = new int(20);  
120.     if (NULL == pValue)  
121.     {  
122.         return;  
123.     }  
124.     HasPtr ptr1(pValue);  
125.     HasPtr ptr2(ptr1);  
126.     HasPtr ptr3 = ptr1;  
127.     HasPtr ptr4(pValue1);  
128.     ptr4 = ptr1;  
129.     cout << endl;  
130. }  
131.   
132.   
133. int main(int argc, char** argv)  
134. {  
135.     test_func();      
136.     return 0;  
137. }