自动化管理资源——std::unique_ptr

C++11之后，STL提供了新的智能指针，能对动态内存进行跟踪管理。C++11之前，C++中也有一个智能指针auto_ptr，也能对内存进行管理，但是很容易被用错。

不过，使用C++11添加的智能指针的话，我们就很少需要使用到new和delete操作符。智能指针是自动化内存管理的一个鲜活的例子。当我们使用unique_ptr来动态分配对象，基本上不会遇到内存泄漏，因为在析构时会自动的为其所拥有内存使用delete操作。

唯一指针表达了其对对象指针的所有权，当对这段内存不在进行使用时，我们会将相关的对象所具有的内存进行释放。这个类将让我们永远远离内存泄漏(智能指针还有shared_ptr和weak_ptr，不过本节中，我们只关注于unique_ptr)。其不会多占用空间，并且不会影响运行时性能，这相较于原始的裸指针和手动内存管理来说十分便捷。(当我们对相应的对象进行销毁后，其内部的裸指针将会被设置为nullptr)。

本节中，我们将来看一下unique_ptr如何使用。

How to do it…

我们将创建一个自定义的类型，在构造和析构函数中添加一些调试打印信息，之后展示unique_ptr如何对内存进行管理。我们将使用unique指针，并使用动态分配的方式对其进行实例化：

  1. 包含必要的头文件，并声明所使用的命名空间：

    1. #include <iostream>
    2. #include <memory>
    4. using namespace std;

  2. 我们将实现一个小类型，后面会使用unque_ptr对其实例进行管理。其构造函数和析构函数都会在终端上打印相应的信息，所以之后的自动删除中，我们会看到相应输出的打印：

    1. class Foo
    2. {
    3. public:
    4.     string name;
    6.     Foo(string n)
    7.         : name{move(n)}
    8.     { cout << "CTOR " << name << '\n'; }
    10.     ~Foo() { cout << "DTOR " << name << '\n'; }
    11. };

  3. 为了了解函数对唯一指针在作为参数传入函数的限制，我们可以实现一个这样的函数。其能处理一个Foo类型实例，并能将其名称进行打印。注意，unique指针是非常智能的，其无额外开销，并且类型安全，也可以为null。这就意味着我们仍然要在解引用之前，对指针进行检查：

    1. void process_item(unique_ptr<Foo> p)
    2. {
    3.     if (!p) { return; }
    5.     cout << "Processing " << p->name << '\n';
    6. }

  4. 主函数中，我们将开辟一个代码段，在堆上创建两个Foo对象，并且使用unique指针对内存进行管理。我们显式的使用new操作符创建第一个对象实例，并且将其用来创建unique_ptr<Foo>变量p1。我们通过make_unique<Foo>的调用来创建第二个unique指针p2，我们直接传入参数对Foo实例进行构建。这种方式更加的优雅，因为我们使用auto类型对类型进行推理，并且能在第一时间对对象进行访问，并且其已经使用unique_ptr进行管理：

    1. int main()
    2. {
    3.     {
    4.         unique_ptr<Foo> p1 {new Foo{"foo"}};
    5.         auto p2 (make_unique<Foo>("bar"));
    6.     }

  5. 离开这个代码段时，所创建的对象将会立即销毁，并且将内存进行释放。让我们来看一下process_item函数和如何使用unique_ptr。当创建一个新的Foo实例时，其就会被unique_ptr进行管理，然后参数的生命周期就在这个函数中。当process_item返回时，这个对象就会被销毁：

    1.     process_item(make_unique<Foo>("foo1"));

  6. 如将已经存在的对象传入process_item函数，就需要将指针的所有权进行转移，因为函数需要使用unique_ptr作为输入参数，这就会有一次拷贝。但是，unique_ptr是无法进行拷贝的，其只能移动。现在让我们来创建两个Foo对象，并且将其中一个移动到process_item函数中。通过对输出的查阅，我们可以了解到foo2在process_item返回时会被析构，因为其所有权已经被转移。foo3将会持续留存于主函数中，直到主函数返回时才进行析构：

    1.     auto p1 (make_unique<Foo>("foo2"));
    2.     auto p2 (make_unique<Foo>("foo3"));
    4.     process_item(move(p1));
    6.     cout << "End of main()\n";
    7. }

  7. 编译并运行程序。首先，我们将看到foo和bar的构造和析构的输出，离开代码段时就被销毁。我们要注意的是，销毁的顺序与创建的顺序相反。下一个构造的就是foo1，其在对process_item调用时进行创建。当函数返回时，其就会被立即销毁。然后，我们会创建foo2和foo3。因为之前转移了指针的所有权，foo2会在process_item函数调用返回时被立即销毁。另一个元素foo3将会在主函数返回时进行销毁：

    1. $ ./unique_ptr
    2. CTOR foo
    3. CTOR bar
    4. DTOR bar
    5. DTOR foo
    6. CTOR foo1
    7. Processing foo1
    8. DTOR foo1
    9. CTOR foo2
    10. CTOR foo3
    11. Processing foo2
    12. DTOR foo2
    13. End of main()
    14. DTOR foo3

How it works…

使用std::unique_ptr来处理堆上分配的对象非常简单。我们初始化unique指针之后，其就会指向对应的对象，这样程序就能自动的对其进行释放操作。

当我们将unique指针赋予一些新指针时，其就会先删除原先指向的对象，然后再存储新的指针。一个unique指针变量x，我们可以使用x.reset()将其目前所指向的对象进行销毁，然后在指向新的对象。另一种等价方式：x = new_pointer与x.reset(new_pointer)的方式等价。

Note：

的确只有一种方式对unique_ptr所指向对象的内存进行释放，那就是使用成员函数release，但这种方式并不推荐使用。

解引用之前，需要对指针进行检查，并且其能使用于裸指针相同的方式进行运算。条件语句类似于if (p){...}和if (p != nullptr){...}，这与我们检查裸指针的方式相同。

解引用一个unique指针可以通过get()函数完成，其会返回一个指向对应对象的裸指针，并且可以直接进行解引用。

unique_ptr有一个很重要的特性——实例无法进行拷贝，只能移动。这就是我们会将已经存在的unique指针的所有权转移到process_item参数的原因。当我们想要拷贝unique指针时，就意味着两个unique指针指向相应的对象，这与该指针的设计理念不符，所以unique指针对其指向对象的所有权必须唯一。

Note：

对于其他的数据类型，由于智能指针的存在，所以很少使用new和delete对其进行手动操作。尽可能的使用智能指针！特别是unqiue_ptr，其在运行时无任何额外开销。