深入 C++ 的 unique_ptr

从异常安全说起

　　使用 raw pointer 管理动态内存时，经常会遇到这样的问题：

忘记delete内存，造成内存泄露。
出现异常时，不会执行delete，造成内存泄露。

　　下面的代码解释了，当一个操作发生异常时，会导致delete不会被执行：

void func() 
{
    auto ptr = new Widget;
    // 执行一个会抛出异常的操作
    func_throw_exception();
    
    delete ptr;
}

　　在 C++98 中我们需要用一种笨拙的方式，写出异常安全的代码：

void func() 
{
    auto ptr = new Widget;
    try {
        func_throw_exception();
    }
    catch(...) {
        delete ptr;
        throw; 
    }
    delete ptr;
}

　　使用智能指针能轻易写出异常安全的代码，因为当对象退出作用域时，智能指针将自动调用对象的析构函数，避免内存泄露：

void func() 
{
    std::unique_ptr<Widget> ptr{ new Widget };
    func_throw_exception();
}

unique_ptr 的原理

　　让我们了解一下unique_ptr的实现细节：

namespace std {
    template <typename T, typename D = default_delete<T>>
    class unique_ptr
    {
    public:
        explicit unique_ptr(pointer p) noexcept;
        ~unique_ptr() noexcept;    
	T& operator*() const;
        T* operator->() const noexcept;
	unique_ptr(const unique_ptr &) = delete;
        unique_ptr& operator=(const unique_ptr &) = delete;
	unique_ptr(unique_ptr &&) noexcept;
	unique_ptr& operator=(unique_ptr &&) noexcept;
	// ...
    private:
        pointer __ptr;
    };
}

　　从上面的代码中，我们可以了解到：

unique_ptr内部存储一个 raw pointer，当unique_ptr析构时，它的析构函数将会负责析构它持有的对象。
unique_ptr提供了operator*()和operator->()成员函数，像 raw pointer 一样，我们可以使用*解引用unique_ptr，使用->来访问unique_ptr所持有对象的成员。
unique_ptr并不提供 copy 操作，这是为了防止多个unique_ptr指向同一对象。
但unique_ptr提供了 move 操作，因此我们可以用std::move()来转移unique_ptr。

　　很显然，缺省情况下，unique_ptr会使用delete析构对象，不过我们可以使用自定义的 deleter。

struct Widget{  };
// ...
auto deleter = []( Widget *p ) {
    cout << "delete Widget!" << endl;
    delete p;
};
unique_ptr<Widget, decltype(deleter)> ptr{ new Widget, deleter };

　　当然，我们可以使用 C++11 的 alias template 特性，这样就可以避免指定 deleter 的类型：

struct Widget{  };
template <typename T>
using uniquePtr = unique_ptr<T, void(*)(T*)>;
void func()
{
    uniquePtr<Widget> ptr( new Widget, 
                           []( Widget *p ) {
                               cout << "delete Widget!" << endl;
                               delete p;
                           });
}

　　unique_ptr为数组提供了模板偏特化，因此unique_ptr也可以指向数组：

namespace std {
    template <typename T, typename D>
    class unique_ptr<T[], D>
    {
    public:
        // ...
        T& operator[]( size_t i ) const;
    };
    template <typename T>
    class default_delete<T[]>
    {
    public:
        // ...
        void operator()( T *p ) const;    // call delete[] p
    };
}

　　当unique_ptr指向数组时，可以使用[]来访问数组元素。default_delete也为数组提供模板偏特化，因此当unique_ptr被销毁时，会调用delete []释放数组内存。

1
2
3

unique_ptr<string[]> ptr{ new string[100] };
ptr[0] = "hello";
ptr[1] = "world";

一些陷阱

　　unique_ptr是用来独占地持有对象的，所以通过同一原生指针来初始化多个unique_ptr，下面是一种错误的使用方式：

struct Widget{  };
Widget *ptr = new Widget;
unique_ptr<Widget> p1{ ptr };
unique_ptr<Widget> p2{ ptr };     // ERROR: multiple ownership

　　当p1和p2各自被销毁的时候，它们指向的Widget将被delete两次。

再谈异常安全

　　C++14 提供了std::make_unique<T>()函数用来直接创建unique_ptr，但 C++11 并没有提供，不过其实现并不复杂：

template <typename T, typename... Ts>
std::unique_ptr<T> make_unique( Ts&&... params ) {
    return std::unique_ptr<T>( new T( std::forward<Ts>(params)... ) );
}
// ...
auto ptr = make_unique<std::string>("senlin");

　　思考一下使用make_unique的好处？

　　使用unique_ptr并不能绝对地保证异常安全，你可能很惊讶于这个结论。让我们看看一个例子：

1	func(unique_ptr<T>{ new T }, func_throw_exception());

　　C++ 标准并没有规定编译器对函数参数的求值次序，所以有可能出现这样的次序：

调用new T分配动态内存。
调用func_throw_exception()函数。
调用unique_ptr的构造函数。

　　调用func_throw_exception()函数会抛出异常，所以无法构造unique_ptr，导致new T所分配的内存不能回收，造成了内存泄露。解决这个问题，需要使用make_unique函数：

1	func(make_unique<T>(), func_throw_exception());

　　这种情况下，成功解决了内存泄露的问题。

　　make_unique在初始化对象的时候使用的()而不是{}，所以下面的代码显然是初始化10个元素：

1
2
3

auto up = make_unique<vector<int>>( 10, 100 );
cout << "size: " << up->size() << endl;
// size: 10

　　但是如果使用std::initializer_list来初始化对象时，要怎样做呢？嗯嗯，看看下面的代码：

auto initList = { 1, 2, 3, 4, 5 };
auto up = make_unique<vector<int>>( initList );
cout << "size: " << up->size() << endl;
// size: 5

从异常安全说起

unique_ptr 的原理

一些陷阱

再谈异常安全

参考资料