智能指针之 unique_ptr

Posted 还在

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了智能指针之 unique_ptr相关的知识,希望对你有一定的参考价值。

  对于动态申请的内存,C++语言为我们提供了new和delete运算符, 而没有像java一样,提供一个完整的GC机制,因此对于我们申请的动态内存,我们需要时刻记得释放,且不能重复释放,释放后不能再去使用...  因此在使用时造成很多不便,且容易出现很多问题,一旦出问题就造成core dump,程序直接挂掉 , 这个时候,智能指针的优势就体现出来了,智能指针符合RAII原则,资源获取就是初始化,在对象析构时,将资源进行释放,对动态内存做到一个比较好的管理

  unique_ptr 持有对对象的独有权—两个unique_ptr不能指向一个对象,不能进行复制操作只能进行移动操作

  unique_ptr拥有所有auto_ptr的功能,且unique_ptr通过将复制构造和赋值操作符私有化,将对象的所有权独有,很好的将auto_ptr的安全问题给规避掉了,unique_ptr的其他特点包括:1.提供删除器释放对象,允许用户自定义删除器 2.添加了对象数组的偏特化实现,new[],delete[] 3.使用C++ 11的右值引用特性,实现所有权转移 std::move()

  本次实现,将unique_ptr的基本接口进行了实现,基本包括了unique_ptr的功能  (编译平台:Linux centos 7.0 编译器:gcc 4.8.5 )

  使用std::unique_ptr时,需要#include <memory>头文件,具体使用代码如下(文件名:test_ptr.cpp):

 1 #include <memory>
 2 #include <iostream>
 3 
 4 using namespace std;
 5 
 6 class Test
 7 {
 8 public:
 9     Test()
10     {
11         cout << "construct.." << endl;
12     }
13     
14     ~Test()    
15     {
16         cout << "destruct.." << endl;
17     }
18 };
19 
20 void test()
21 {
22     
23 }
24 
25 int main()
26 {
27     //auto_ptr
28     Test* p = new Test(); 
29     auto_ptr<Test> ap(p);
30     
31     //unique_ptr
32     Test* p1 = new Test();
33     unique_ptr<Test> up(new Test());
34     unique_ptr<Test> up1(move(up));
35 
36     
37 
38     //unique_ptr<Test> up2 = up;
39     
40     unique_ptr<int> up3(new int(5));
41 
42     return 0;
43 }

  具体实现代码如下,没有对动态对象数组及std::move()进行实现,动态对象数组实现代码和这差不多,写个模板偏特化即可,至于std::move()则和成员函数release()类似,转移所有权(文件名:unique_ptr_implement.cpp):

  1 #include <iostream>
  2 #include <assert.h>
  3 
  4 using namespace std;
  5 
  6 #define PTR_ASSERT(x) assert(x)
  7 
  8 template<class T>
  9 struct defalute_deleter
 10 {
 11     void defalute_deleter_method()
 12     {
 13         cout << "deleter method..." << endl;
 14     }
 15     void operator()(T* ptr)
 16     {
 17         if(ptr != NULL)
 18         {
 19             cout << "default deleter....." << endl;
 20             delete ptr;
 21             ptr = NULL;
 22         }
 23     }
 24 };
 25 
 26 template<typename T, typename deleter = defalute_deleter<T> >
 27 class unique_ptr
 28 {
 29 public:
 30     explicit unique_ptr(T* ptr = NULL);
 31     
 32     unique_ptr(T* ptr, deleter d);
 33 
 34     ~unique_ptr();
 35 
 36     T* get();
 37 
 38     void reset(T* ptr = NULL);
 39 
 40     deleter& getDeleter();
 41 
 42     T* release();
 43 
 44 public:
 45     T& operator*();    
 46     
 47     T* operator->();
 48 
 49     operator bool() const;
 50     
 51 private:
 52     unique_ptr(unique_ptr& up);
 53 
 54     unique_ptr& operator = (unique_ptr& up);
 55     
 56 private:
 57     T* m_ptr;
 58 
 59     deleter m_deleter;
 60 };
 61 
 62 template<typename T, typename deleter>
 63 unique_ptr<T, deleter>::unique_ptr(T* ptr /* = NULL */, deleter d)
 64 {
 65     if(ptr != NULL)
 66     {
 67         m_ptr = ptr;
 68         m_deleter = d;
 69     }
 70 }
 71 
 72 template<typename T, typename deleter>
 73 unique_ptr<T, deleter>::unique_ptr(T* ptr /* = NULL */)
 74 {
 75     if(ptr != NULL)
 76     {
 77         m_ptr = ptr;
 78     }    
 79 }
 80 
 81 template<typename T, typename deleter>
 82 unique_ptr<T, deleter>::~unique_ptr()
 83 {
 84     if(m_ptr != NULL)
 85     {
 86         m_deleter(m_ptr);
 87         m_ptr = NULL;
 88     }
 89 }
 90 
 91 template<typename T, typename deleter>
 92 T& unique_ptr<T, deleter>::operator*()
 93 {
 94     PTR_ASSERT(m_ptr != NULL);
 95 
 96     return *m_ptr;
 97 }
 98 
 99 template<class T, class deleter>
100 T* unique_ptr<T, deleter>::operator->()
101 {
102     PTR_ASSERT(m_ptr != NULL);
103 
104     return m_ptr;
105 }
106 
107 template<typename T, typename deleter>
108 T* unique_ptr<T, deleter>::get()
109 {
110     return m_ptr;
111 }
112 
113 template<typename T, typename deleter>
114 void unique_ptr<T, deleter>::reset(T* ptr)
115 {
116     T* old_ptr = m_ptr;
117     m_ptr = ptr;
118 
119     if(old_ptr != NULL)
120     {
121         m_deleter(old_ptr);
122         old_ptr = NULL;
123     }
124 }
125 
126 template<typename T, typename deleter>
127 deleter& unique_ptr<T, deleter>::getDeleter()
128 {
129     return m_deleter;
130 }
131 
132 template<typename T, typename deleter>
133 T* unique_ptr<T, deleter>::release()
134 {
135     T* pTemp = m_ptr;
136     m_ptr = NULL;
137 
138     return pTemp;    
139 }
140 
141 template<typename T, typename deleter>
142 unique_ptr<T, deleter>::operator bool() const
143 {
144     return m_ptr != NULL;
145 }
146 
147 
148 //Test class
149 class Test
150 {
151 public:
152     Test()
153     {
154         cout << "construct.." << endl;
155     }
156     
157     ~Test()    
158     {
159         cout << "destruct.." << endl;
160     }
161 
162     void method()
163     {
164         cout << "welcome Test.." << endl;
165     }
166 };
167 
168 //custom deleter
169 template <class T>
170 struct custom_deleter
171 {
172     void deleter_method()
173     {
174         cout << "custom deleter method..." << endl;
175     }
176 
177     void operator()(T* ptr)
178     {
179         cout << "custom deleter... " << endl;
180         delete ptr;
181         ptr = NULL;
182     }
183 };
184 
185 
186 int main()
187 {
188     //default deleter
189     cout << "=======default deleter====interface test begin: ========== " << endl;
190     unique_ptr<Test> up(new Test());
191     
192     cout << "operator ->: " << endl;
193     up->method();
194     
195     cout << "operator *: " << endl;
196     (*up).method();
197 
198     cout << "operator bool: " << endl;
199     if(up){ cout<< "obj is exit" << endl;}
200 
201     cout << "get: " << endl;
202     up.get()->method();
203 
204     cout << "getDeleter: " << endl;
205     defalute_deleter<Test> del = up.getDeleter();
206     del.defalute_deleter_method();
207 
208     cout << "release: " << endl;
209     unique_ptr<Test> up1(up.release());
210 
211     //if take this,  will die
212     //(*up).method();
213 
214     cout << "reset: " << endl;
215     up1.reset();
216 
217     //Custom deleter
218     cout << "=======Custom deleter====interface test begin: ========== " << endl;
219     custom_deleter<Test> d;
220     unique_ptr<Test, custom_deleter<Test> > up_custom_dele(new Test(), d);
221     
222     cout << "operator ->: " << endl;
223     up_custom_dele->method();
224     
225     cout << "operator *: " << endl;
226     (*up_custom_dele).method();
227 
228     cout << "operator bool: " << endl;
229     if(up_custom_dele){ cout<< "obj is exit" << endl;}
230 
231     cout << "get: " << endl;
232     up_custom_dele.get()->method();
233 
234     cout << "getDeleter: " << endl;
235     custom_deleter<Test> custom_del = up_custom_dele.getDeleter();
236     custom_del.deleter_method();
237 
238     cout << "release: " << endl;
239     unique_ptr<Test> up3(up_custom_dele.release());
240 
241     //if take this,  will die
242     //(*up_custom_dele).method();
243 
244     cout << "reset: " << endl;
245     up3.reset();
246     
247 
248     return 0;
249 }

  执行代码,打印如下:

 1 [[email protected] code]# g++ -o unique unique_ptr_implement.cpp 
 2 [[email protected] code]# ./unique
 3 =======default deleter====interface test begin: ========== 
 4 construct..
 5 operator ->: 
 6 welcome Test..
 7 operator *: 
 8 welcome Test..
 9 operator bool: 
10 obj is exit
11 get: 
12 welcome Test..
13 getDeleter: 
14 deleter method...
15 release: 
16 reset: 
17 default deleter.....
18 destruct..
19 =======Custom deleter====interface test begin: ========== 
20 construct..
21 operator ->: 
22 welcome Test..
23 operator *: 
24 welcome Test..
25 operator bool: 
26 obj is exit
27 get: 
28 welcome Test..
29 getDeleter: 
30 custom deleter method...
31 release: 
32 reset: 
33 default deleter.....
34 destruct..
35 [[email protected] code]# 

  从实现结果可以看出,unique_ptr保证一个动态对象只有一个unique_ptr对象所拥有,unique_ptr对象之间无法copy和赋值,只能进行动态内存对象的转移,转移时,原有的unique_ptr对象将不再拥有动态内存的访问权限,这样可以保证动态内存使用的安全性。在实现中构造函数提供了两个,一个使用默认删除器,另一个则需要我们构造时传入删除器,这样可以很好的进行资源自定义删除。 对于多个指针对象指向同一个动态内存对象,unique_ptr不适用,需使用share_ptr

 

以上是关于智能指针之 unique_ptr的主要内容,如果未能解决你的问题,请参考以下文章

C++11 unique_ptr智能指针详解

C++11之智能指针(unique_ptrshared_ptrweak_ptrauto_ptr)浅谈内存管理

智能指针unique_ptr用法

智能指针之 auto_ptr

[C++11]独占的智能指针unique_ptr的删除器

[C++11]独占的智能指针unique_ptr的初始化和使用