C++11中unique_ptr的使用

C++11中unique_ptr的使用

阅读数：7537

在C++中，动态内存的管理是通过一对运算符来完成的：new，在动态内存中为对象分配空间并返回一个指向该对象的指针，可以选择对对象进行初始化；delete，接受一个动态对象的指针，销毁该对象，并释放与之关联的内存。

动态内存的使用很容易出问题，因为确保在正确的时间释放内存是极其困难的。有时会忘记释放内存，在这种情况下会产生内存泄露；有时在尚有指针引用内存的情况下就释放了它，在这种情况下就会产生引用非法内存的指针。

为了更容易(同时也更安全)地使用动态内存，C++11标准库提供了两种智能指针(smart pointer)类型来管理动态对象。智能指针的行为类似常规指针，重要的区别是它负责自动释放所指的对象。C++11标准库提供的这两种智能指针的区别在于管理底层指针的方式：shared_ptr允许多个指针指向同一个对象；unique_ptr则"独占"所指向的对象。C++11标准库还定义了一个名为weak_ptr的辅助类，它是一种弱引用，指向shared_ptr所管理的对象。这三种类型都定义在memory头文件中。智能指针是模板类而不是指针。类似vector，智能指针也是模板，当创建一个智能指针时，必须提供额外的信息即指针可以指向的类型。默认初始化的智能指针中保存着一个空指针。智能指针的使用方式与普通指针类似。解引用一个智能指针返回它指向的对象。如果在一个条件判断中使用智能指针，效果就是检测它是否为空。

In C++, a smart pointer is implemented as a template class that mimics, by means of operator overloading, the behaviors of a traditional (raw) pointer, (e.g. dereferencing, assignment) while providing additional memory management features.

std::unique_ptr is a smart pointer that retains sole ownership of an object through a pointer and destroys that object when the unique_ptr goes out of scope. No two unique_ptr instances can manage the same object.

The object is destroyed and its memory deallocated when either of the following happens: (1)、the managing unique_ptr object is destroyed; (2)、the managing unique_ptr object is assigned another pointer via operator= or reset().

A unique_ptr may alternatively own no object, in which case it is called empty.

Only non-const unique_ptr can transfer the ownership of the managed object to another unique_ptr. The lifetime of an object managed by const std::unique_ptr is limited to the scope in which the pointer was created.

std::unique_ptr may be constructed for an incomplete type T. Conversely, std::shared_ptr can't be constructed from a raw pointer to incomplete type, but can be destroyed where T is incomplete.

A unique_ptr does not share its pointer. It cannot be copied to another unique_ptr, passed by value to a function, or used in any Standard Template Library (STL) algorithm that requires copies to be made. A unique_ptr can only be moved. This means that the ownership of the memory resource is transferred to another unique_ptr and the original unique_ptr no longer owns it.

When using unique_ptr, there can be at most one unique_ptr pointing at any one resource.When that unique_ptr is destroyed, the resource is automatically reclaimed.Because there can only be one unique_ptr to any resource, any attempt to make a copy of a unique_ptr will cause a compile-time error. However, unique_ptr can be moved using the new move semantics.

shared_ptr, allows for multiple pointers to point at a given resource. When the very last shared_ptr to a resource is destroyed, the resource will be deallocated. shared_ptr uses reference counting to track how many pointers refer to a resource, so you need to be careful not to introduce any reference cycles.

A unique_ptr is a container for a raw pointer, which the unique_ptr is said to own. A unique_ptr explicitly prevents copying of its contained pointer (as would happen with normal assignment), but the std::move function can be used to transfer ownership of the contained pointer to another unique_ptr. A unique_ptr cannot be copied because its copy constructor and assignment operators are explicitly deleted.

everything you can do with auto_ptr, unique_ptr will do as well.

There are two kinds of unique_ptr, one for scalars (i.e. non-arrays) and one for arrays:

(1)、unique_ptr<double> can hold a scalar of type double;

(2)、unique_ptr<double[]> can hold an array of double values with an unknown number of elements.

         std::unique_ptr是C++11标准中用来取代std::auto_ptr的指针容器(在C++11中，auto_ptr被废弃)。它不能与其它unique_ptr类型的指针对象共享所指对象的内存。这种”所有权”仅能够通过标准库的move函数来转移。unique_ptr是一个删除了拷贝构造函数、保留了移动构造函数的指针封装类型。

一个unique_ptr"拥有"它所指向的对象。与shared_ptr不同，某个时刻只能有一个unique_ptr指向一个给定对象。当unique_ptr被销毁时，它所指向的对象也被销毁。与shared_ptr不同，在C++11中，没有类似make_shared的标准库函数返回一个unique_ptr。当定义一个unique_ptr时，需要将其绑定到一个new返回的指针上。类似shared_ptr，初始化unique_ptr必须采用直接初始化形式。由于一个unique_ptr拥有它指向的对象，因此unique_ptr不支持普通的拷贝或赋值操作。虽然不能拷贝或赋值unique_ptr，但可以通过调用release或reset将指针的所有权从一个(非const)unique_ptr转移给另一个unique。

调用release会切断unique_ptr和它原来管理的对象间的联系。release返回的指针通过被用来初始化另一个智能指针或给另一个智能指针赋值。如果不用另一个智能指针来保存release返回的指针，程序就要负责资源的释放。

不能拷贝unique_ptr的规则有一个例外：我们可以拷贝或赋值一个将要被销毁的unique_ptr，最常见的例子是从函数返回一个unique_ptr。

类似shared_ptr，unique_ptr默认情况下用delete释放它指向的对象。与shared_ptr一样，可以重载一个unique_ptr中默认的删除器。但是，unique_ptr管理删除器的方式与shared_ptr不同。

下图列出了unique_ptr支持的操作(来源于C++ Primer Fifth Edition 中文版)：

下面是从其他文章中copy的测试代码，详细内容介绍可以参考对应的reference：

[cpp]   view plain  copy

1. #include "unique_ptr.hpp"  
2. #include <iostream>  
3. #include <memory>  
4. #include <string>  
5. #include <cstdlib>  
6. #include <utility>  
7. #include <vector>  
8. #include <algorithm>  
9.   
10. ///  
11. // reference: http://en.cppreference.com/w/cpp/memory/unique_ptr  
12. struct Foo  
13. {  
14.     Foo()      { std::cout << "Foo::Foo\n"; }  
15.     ~Foo()     { std::cout << "Foo::~Foo\n"; }  
16.     void bar() { std::cout << "Foo::bar\n"; }  
17. };  
18.   
19. void f(const Foo &)  
20. {  
21.     std::cout << "f(const Foo&)\n";  
22. }  
23.   
24. int test_unique_ptr1()  
25. {  
26.     std::unique_ptr<Foo> p1(new Foo);  // p1 owns Foo  
27.     if (p1) p1->bar();  
28.   
29.     {  
30.         std::unique_ptr<Foo> p2(std::move(p1));  // now p2 owns Foo  
31.         f(*p2);  
32.   
33.         p1 = std::move(p2);  // ownership returns to p1  
34.         std::cout << "destroying p2...\n";  
35.     }  
36.   
37.     if (p1) p1->bar();  
38.   
39.     // Foo instance is destroyed when p1 goes out of scope  
40.   
41.     return 0;  
42. }  
43.   
44. //  
45. // reference: http://www.cplusplus.com/reference/memory/unique_ptr/unique_ptr/  
46. int test_unique_ptr2()  
47. {  
48.     std::default_delete<int> d;  
49.     std::unique_ptr<int> u1;  
50.     std::unique_ptr<int> u2(nullptr);  
51.     std::unique_ptr<int> u3(new int);  
52.     std::unique_ptr<int> u4(new int, d);  
53.     std::unique_ptr<int> u5(new int, std::default_delete<int>());  
54.     std::unique_ptr<int> u6(std::move(u5));  
55.     std::unique_ptr<int> u7(std::move(u6));  
56.     std::unique_ptr<int> u8(std::auto_ptr<int>(new int));  
57.   
58.     std::cout << "u1: " << (u1 ? "not null" : "null") << '\n';  
59.     std::cout << "u2: " << (u2 ? "not null" : "null") << '\n';  
60.     std::cout << "u3: " << (u3 ? "not null" : "null") << '\n';  
61.     std::cout << "u4: " << (u4 ? "not null" : "null") << '\n';  
62.     std::cout << "u5: " << (u5 ? "not null" : "null") << '\n';  
63.     std::cout << "u6: " << (u6 ? "not null" : "null") << '\n';  
64.     std::cout << "u7: " << (u7 ? "not null" : "null") << '\n';  
65.     std::cout << "u8: " << (u8 ? "not null" : "null") << '\n';  
66.   
67.     return 0;  
68. }  
69.   
70. //  
71. // reference: http://eli.thegreenplace.net/2012/06/20/c11-using-unique_ptr-with-standard-library-containers  
72. struct Foo_0 {  
73.     Foo_0() { std::cerr << "Foo_0 [" << this << "] constructed\n"; }  
74.     virtual ~Foo_0() { std::cerr << "Foo_0 [" << this << "] destructed\n"; }  
75. };  
76.   
77. void sink(std::unique_ptr<Foo_0> p) {  
78.     std::cerr << "Sink owns Foo_0 [" << p.get() << "]\n";  
79. }  
80.   
81. std::unique_ptr<Foo_0> source() {  
82.     std::cerr << "Creating Foo_0 in source\n";  
83.     return std::unique_ptr<Foo_0>(new Foo_0);  
84. }  
85.   
86. int test_unique_ptr3()  
87. {  
88.     std::cerr << "Calling source\n";  
89.     std::unique_ptr<Foo_0> pmain = source();  // Can also be written as  
90.     // auto pmain = source();  
91.   
92.     std::cerr << "Now pmain owns Foo [" << pmain.get() << "]\n";  
93.     std::cerr << "Passing it to sink\n";  
94.     // sink(pmain);                    // ERROR! can't copy unique_ptr  
95.     sink(move(pmain));              // OK: can move it!  
96.   
97.     std::cerr << "Main done\n";  
98.     return 0;  
99. }  
100.   
101.   
102. // reference: http://www.codeguru.com/cpp/article.php/c17775/The-Smart-Pointer-That-Makes-Your-C-Applications-Safer--stduniqueptr.htm  
103. void func(int*)  
104. {  
105.   
106. }  
107.   
108. int test_unique_ptr4()  
109. {  
110.     // default construction  
111.     std::unique_ptr<int> up; //creates an empty object  
112.   
113.     // initialize with an argument  
114.     std::unique_ptr<int> uptr(new int(3));  
115.     double *pd = new double;  
116.     std::unique_ptr<double> uptr2(pd);  
117.     // overloaded * and ->  
118.     *uptr2 = 23.5;  
119.     std::unique_ptr<std::string> ups(new std::string("hello"));  
120.     int len = ups->size();  
121.   
122.     // Reset() releases the owned resource and optionally acquires a new resource:  
123.     uptr2.reset(new double); //delete pd and acquire a new pointer  
124.     uptr2.reset(); //delete the pointer acquired by the previous reset() call  
125.   
126.     // If you need to access the owned pointer directly use get()  
127.     func(uptr.get());  
128.   
129.     // Unique_ptr has implicit conversion to bool.  
130.     // This lets you use unique_ptr object in Boolean expressions such as this:  
131.     if (ups) //implicit conversion to bool  
132.         std::cout << *ups << std::endl;  
133.     else  
134.         std::cout << "an empty smart pointer" << std::endl;  
135.   
136.     // Array Support: Unique_ptr can store arrays as well.  
137.     // A unique_ptr that owns an array defines an overloaded operator [].  
138.     // Obviously, the * and -> operators are not available.  
139.     // Additionally, the default deleter calls delete[] instead of delete:  
140.     std::unique_ptr<int[]> arrup(new int[5]);  
141.     arrup[0] = 5;  
142.     // std::cout << *arrup << std::endl; //error, operator * not defined   
143.   
144.     // Compatibility with Containers and Algorithms  
145.     // You can safely store unique_ptr in Standard Library containers and let algorithms manipulate sequences of unique_ptr objects.  
146.     std::vector<std::unique_ptr<int>> vi;  
147.     vi.push_back(std::unique_ptr<int>(new int(0)));  // populate vector  
148.     vi.push_back(std::unique_ptr<int>(new int(3)));  
149.     vi.push_back(std::unique_ptr<int>(new int(2)));  
150.     std::sort(vi.begin(), vi.end());  // result: {0, 2, 3}  
151.   
152.     return 0;  
153. }  
154.   
155. //  
156. template <typename T>  
157. class Add {  
158. public:  
159.     T add_sub(T a, T b)  
160.     {  
161.         return (a + b) * (a - b);  
162.     }  
163. };  
164.   
165.   
166. int test_unique_ptr5()  
167. {  
168.     std::unique_ptr<Add<int>> tt(new Add<int>());  
169.     int a{ 10 }, b{ 5 };  
170.   
171.     std::cout << tt->add_sub(a, b) << std::endl;  
172.   
173.     return 0;  
174. }  
175.   
176. //  
177. int test_unique_ptr6()  
178. {  
179.     std::unique_ptr<int[]> tmp(new int[100]);  
180.     std::for_each(tmp.get(), tmp.get() + 100, [](int& n) {n = 66; });  
181.     std::cout << tmp[99] << std::endl;  
182.   
183.     return 0;  
184. }  

GitHub： https://github.com/fengbingchun/Messy_Test