C++参悟：内存管理-unique_ptr

一、概述

std::unique_ptr 是通过指针占有并管理另一对象，并在 unique_ptr 离开作用域时释放该对象的智能指针。相当于一个对象的指针只会被一堆 unique_ptr 中某一个被占用，而且这个对象的指针不能被其他unique_ptr 占用。这个同时还有作用域的限制。

在下列的两个情况下会用调用 unique_ptr 关联的 Deleter 删除器释放对象：

• 销毁了用于管理的 unique_ptr 对象
• 通过 operator= 或 reset() 赋值另一指针给管理的 unique_ptr 对象

通过调用 get_deleter()(ptr) ，用潜在为用户提供的删除器释放对象。默认删除器用 delete 运算符，它销毁定义的unique_ptr 对象并是否这个指针对象的分配内存。

这个的类的定义如下，可以看到，参数有两个，一个是待分配的类型，一个是删除器

template< 
	class T,
	class Deleter = std::default_delete<T>
> class unique_ptr; 

template < 
    class T,
    class Deleter
> class unique_ptr<T[], Deleter>; 

unique_ptr 亦可以不占有对象，该情况下称它为空 (empty)。

std::unique_ptr 有两个版本：

1. 管理单个对象（例如以 new 分配）

2. 管理动态分配的对象数组（例如以 new[] 分配）

注解：

只有非 const 的 unique_ptr 能转移被管理对象的所有权给另一 unique_ptr 。若对象的生存期为 const std::unique_ptr 所管理，则它被限定在创建指针的作用域中。

std::unique_ptr 常用于管理对象的生存期，包含：

• 通过正常退出和经由异常退出两者上的受保证删除，提供异常安全，给处理拥有动态生存期的对象的类和函数
• 传递独占的拥有动态生存期的对象的所有权到函数
• 从函数获得独占的拥有动态生存期对象的所有权
• 作为具移动容器的元素类型，例如保有指向动态分配对象的指针的 std::vector （例如，若想要多态行为）

std::unique_ptr 可为不完整类型 T 构造，例如用于改善用作 pImpl 手法中柄的用途。若使用默认删除器，则 T 必须在代码中调用删除器点处完整，这发生于析构函数、移动赋值运算符和 std::unique_ptr 的 reset 成员函数中。（相反地， std::shared_ptr 不能从指向不完整类型的裸指针构造，但可于 T 不完整处销毁）。注意若 T 是类模板特化，则以 unique_ptr 为运算数的使用，如 !p ，因 ADL 而要求 T 的形参完整。

若 T 是某基类 B 的派生类，则 std::unique_ptr 可隐式转换为 std::unique_ptr。产生的 std::unique_ptr 的默认删除器将使用 B 的 operator delete ，这导致未定义行为，除非 B 的析构函数为虚。注意 std::shared_ptr 表现有别： std::shared_ptr 将使用类型 T 的 operator delete ，而且即使 B 的析构函数非虚，也会正确删除被占有对象。

不同于 std::shared_ptr ， std::unique_ptr 可通过任何满足可空指针 (NullablePointer) 的定制柄类型管理对象。例如，这允许管理位于共享内存，但提供定义 typedef boost::offset_ptr pointer; 或其他缀饰指针的 Deleter 的对象。

例子：

#include 
#include 
#include 
#include 
#include 
#include 
#include 
 
struct B {
  virtual void bar() { std::cout << "B::bar\n"; }
  virtual ~B() = default;
};
struct D : B
{
    D() { std::cout << "D::D\n";  }
    ~D() { std::cout << "D::~D\n";  }
    void bar() override { std::cout << "D::bar\n";  }
};
 
// 消费 unique_ptr 的函数能以值或以右值引用接收它
std::unique_ptr<D> pass_through(std::unique_ptr<D> p)
{
    p->bar();
    return p;
}
 
void close_file(std::FILE* fp) { std::fclose(fp); }
 
int main()
{
  std::cout << "unique ownership semantics demo\n";
  {
      auto p = std::make_unique<D>(); // p 是占有 D 的 unique_ptr
      auto q = pass_through(std::move(p)); 
      assert(!p); // 现在 p 不占有任何内容并保有空指针
      q->bar();   // 而 q 占有 D 对象
  } // ~D 调用于此
 
  std::cout << "Runtime polymorphism demo\n";
  {
    std::unique_ptr<B> p = std::make_unique<D>(); // p 是占有 D 的 unique_ptr
                                                  // 作为指向基类的指针
    p->bar(); // 虚派发
 
    std::vector<std::unique_ptr<B>> v;  // unique_ptr 能存储于容器
    v.push_back(std::make_unique<D>());
    v.push_back(std::move(p));
    v.emplace_back(new D);
    for(auto& p: v) p->bar(); // 虚派发
  } // ~D called 3 times
 
  std::cout << "Custom deleter demo\n";
  std::ofstream("demo.txt") << 'x'; // 准备要读的文件
  {
      std::unique_ptr<std::FILE, void (*)(std::FILE*) > fp(std::fopen("demo.txt", "r"),
                                                           close_file);
      if(fp) // fopen 可以打开失败；该情况下 fp 保有空指针
        std::cout << (char)std::fgetc(fp.get()) << '\n';
  } // fclose() 调用于此，但仅若 FILE* 不是空指针
    // （即 fopen 成功）
 
  std::cout << "Custom lambda-expression deleter demo\n";
  {
    std::unique_ptr<D, std::function<void(D*)>> p(new D, [](D* ptr)
        {
            std::cout << "destroying from a custom deleter...\n";
            delete ptr;
        });  // p 占有 D
    p->bar();
  } // 调用上述 lambda 并销毁 D
 
  std::cout << "Array form of unique_ptr demo\n";
  {
      std::unique_ptr<D[]> p{new D[3]};
  } // 调用 ~D 3 次
}
//输出：

unique ownership semantics demo
D::D
D::bar
D::bar
D::~D
Runtime polymorphism demo
D::D
D::bar
D::D
D::D
D::bar
D::bar
D::bar
D::~D
D::~D
D::~D
Custom deleter demo
x
Custom lambda-expression deleter demo
D::D
D::bar
destroying from a custom deleter...
D::~D
Array form of unique_ptr demo
D::D
D::D
D::D
D::~D
D::~D
D::~D

二、成员函数

1. 构造、析构函数函数

1. 构造函数

#include 
#include 
 
struct Foo { // 要管理的对象
    Foo() { std::cout << "Foo ctor\n"; }
    Foo(const Foo&) { std::cout << "Foo copy ctor\n"; }
    Foo(Foo&&) { std::cout << "Foo move ctor\n"; }
    ~Foo() { std::cout << "~Foo dtor\n"; }
};
 
struct D { // 删除器
    D() {};
    D(const D&) { std::cout << "D copy ctor\n"; }
    D(D&) { std::cout << "D non-const copy ctor\n";}
    D(D&&) { std::cout << "D move ctor \n"; }
    void operator()(Foo* p) const {
        std::cout << "D is deleting a Foo\n";
        delete p;
    };
};
 
int main()
{
    std::cout << "Example constructor(1)...\n";
    std::unique_ptr<Foo> up1;  // up1 为空
    std::unique_ptr<Foo> up1b(nullptr);  // up1b 为空
 
    std::cout << "Example constructor(2)...\n";
    {
        std::unique_ptr<Foo> up2(new Foo); // up2 现在占有 Foo
    } // Foo 被删除
 
    std::cout << "Example constructor(3)...\n";
    D d;
    {  // 删除器类型不是引用
       std::unique_ptr<Foo, D> up3(new Foo, d); // 复制删除器
    }
    {  // 删除器类型是引用 
       std::unique_ptr<Foo, D&> up3b(new Foo, d); // up3b 保有到 d 的引用
    }
 
    std::cout << "Example constructor(4)...\n";
    {  // 删除器不是引用
       std::unique_ptr<Foo, D> up4(new Foo, D()); // 移动删除器
    }
 
    std::cout << "Example constructor(5)...\n";
    {
       std::unique_ptr<Foo> up5a(new Foo);
       std::unique_ptr<Foo> up5b(std::move(up5a)); // 所有权转移
    }
 
    std::cout << "Example constructor(6)...\n";
    {
        std::unique_ptr<Foo, D> up6a(new Foo, d); // 复制 D
        std::unique_ptr<Foo, D> up6b(std::move(up6a)); // 移动 D
 
        std::unique_ptr<Foo, D&> up6c(new Foo, d); // D 是引用
        std::unique_ptr<Foo, D> up6d(std::move(up6c)); // 复制 D
    }
 
#if (__cplusplus < 201703L)
    std::cout << "Example constructor(7)...\n";
    {
        std::auto_ptr<Foo> up7a(new Foo);
        std::unique_ptr<Foo> up7b(std::move(up7a)); // 所有权转移
    }
#endif
 
    std::cout << "Example array constructor...\n";
    {
        std::unique_ptr<Foo[]> up(new Foo[3]);
    } // 删除三个 Foo 对象
}
// 输出：

Example constructor(1)...
Example constructor(2)...
Foo ctor
~Foo dtor
Example constructor(3)...
Foo ctor
D copy ctor
D is deleting a Foo
~Foo dtor
Foo ctor
D is deleting a Foo
~Foo dtor
Example constructor(4)...
Foo ctor
D move ctor 
D is deleting a Foo
~Foo dtor
Example constructor(5)...
Foo ctor
~Foo dtor
Example constructor(6)...
Foo ctor
D copy ctor
D move ctor 
Foo ctor
D non-const copy ctor
D is deleting a Foo
~Foo dtor
D is deleting a Foo
~Foo dtor
Example constructor(7)...
Foo ctor
~Foo dtor
Example array constructor...
Foo ctor
Foo ctor
Foo ctor
~Foo dtor
~Foo dtor
~Foo dtor

2. 析构函数

// 下列程序演示定制删除器的用法。

#include 
#include 
 
int main () 
{
    auto deleter = [](int* ptr){
        std::cout << "[deleter called]\n";
        delete ptr;
    };
 
    std::unique_ptr<int,decltype(deleter)> uniq(new int, deleter);
    std::cout << (uniq ? "not empty\n" : "empty\n");
    uniq.reset();
    std::cout << (uniq ? "not empty\n" : "empty\n");
}
//输出：

not empty
[deleter called]
empty

3. 赋值号

作为只能被移动的类型，unique_ptr 的赋值运算符只接受右值实参（例如 std::make_unique 的结果或已被 std::move 的 unique_ptr 变量）。

#include 
#include 
 
struct Foo
{
    int id;
    Foo(int id) : id(id) { std::cout << "Foo " << id << '\n'; }
    ~Foo() { std::cout << "~Foo " << id << '\n'; }
};
 
int main() 
{
    std::unique_ptr<Foo> p1(std::make_unique<Foo>(1));
 
    {
        std::cout << "创建新的 Foo...\n";
        std::unique_ptr<Foo> p2(std::make_unique<Foo>(2));
        // p1 = p2; // 错误！不能复制 unique_ptr
        p1 = std::move(p2);
        std::cout << "准备离开内层块...\n";
 
        // 即使 p2 将要离开作用域，但是 Foo 示例会继续生存
    }
 
    std::cout << "准备离开程序...\n";
}
//输出：

Foo 1
创建新的 Foo...
Foo 2
~Foo 1
准备离开内层块...
准备离开程序...
~Foo 2

2. 修改器

1. release（）

若存在，则释放被管理对象的所有权。调用这个函数后再去 get() 就返回 nullptr 。这个本身也返回的是 nullptr值。

调用方负责删除该对象。

指向被管理对象的指针，或若无被管理对象则为 nullptr ，即调用前 get() 会返回的值。

#include 
#include 
#include 
 
struct Foo
{
    Foo() { std::cout << "Foo\n"; }
    ~Foo() { std::cout << "~Foo\n"; }
};
 
// Foo资源的所有权在调用该函数时被转移
void legacy_api(Foo* owning_foo)
{
    std::cout << __func__ << '\n';
    // 没有人能理解或再敢碰的遗留代码
    // ...
    delete owning_foo;
}
 
int main()
{
    std::unique_ptr<Foo> managed_foo(new Foo);
 
    legacy_api(managed_foo.release());
 
    assert(managed_foo == nullptr);
}
//输出：

Foo
legacy_api
~Foo

2. reset()

定义：void reset( pointer ptr = pointer() ) noexcept;

为在提供新删除器时替换被管理对象，可用移动赋值运算符。

不进行自 reset 测试，即 ptr 是否指向已为 *this 管理的对象，除非作为编译器扩展，或调试断言提供。注意如 p.reset(p.release()) 的代码不涉及自重置，只有类似 p.reset(p.get()) 的代码会。

示例

#include 
#include 
 
struct Foo {
    Foo() { std::cout << "Foo...\n"; }
    ~Foo() { std::cout << "~Foo...\n"; }
};
 
struct D {
    void operator() (Foo* p) {
        std::cout << "Calling delete for Foo object... \n";
        delete p;
    }
};
 
int main()
{
    std::cout << "Creating new Foo...\n";
    std::unique_ptr<Foo, D> up(new Foo(), D());  // up 占有 Foo 指针（删除器 D ）
 
    std::cout << "Replace owned Foo with a new Foo...\n";
    up.reset(new Foo());  // 调用旧者的删除器
 
    std::cout << "Release and delete the owned Foo...\n";
    up.reset(nullptr);      
}
//输出：

Creating new Foo...
Foo...
Replace owned Foo with a new Foo...
Foo...
Calling delete for Foo object...
~Foo...
Release and delete the owned Foo...
Calling delete for Foo object...
~Foo...

3. swap()

void swap(unique_ptr& other) noexcept;

交换 *this 和另一 unique_ptr 对象 other 的被管理对象和关联的删除器。

#include 
#include 
 
struct Foo {
    Foo(int _val) : val(_val) { std::cout << "Foo...\n"; }
    ~Foo() { std::cout << "~Foo...\n"; }
    int val;
};
 
int main()
{
    std::unique_ptr<Foo> up1(new Foo(1));
    std::unique_ptr<Foo> up2(new Foo(2));
 
    up1.swap(up2);
 
    std::cout << "up1->val:" << up1->val << std::endl;
    std::cout << "up2->val:" << up2->val << std::endl;
}
//输出：

Foo...
Foo...
up1->val:2
up2->val:1
~Foo...
~Foo...

3. 观察器

1. get()

返回指向被管理对象的指针，如果无被管理对象，则为 nullptr 。

#include 
#include 
#include 
#include 
#include 
 
class Res {
    std::string s;
 
public:
    Res(std::string arg) : s{ std::move(arg) } {
        std::cout << "Res::Res(" << std::quoted(s) << ");\n";
    }
 
    ~Res() {
        std::cout << "Res::~Res();\n";
    }
 
private:
    friend std::ostream& operator<< (std::ostream& os, Res const& r) {
        return os << "Res { s = " << std::quoted(r.s) << "; }";
    }
};
 
int main()
{
    std::unique_ptr<Res> up(new Res{"Hello, world!"});
    Res *res = up.get();
    std::cout << *res << '\n';
}
//输出：

Res::Res("Hello, world!");
Res { s = "Hello, world!"; }
Res::~Res();

2. get_deleter

返回会用于析构被管理对象的删除器对象。

#include 
#include 
 
struct Foo
{
    Foo() { std::cout << "Foo...\n"; }
    ~Foo() { std::cout << "~Foo...\n"; }
};
 
struct D
{
    void bar() { std::cout << "Call deleter D::bar()...\n"; }
    void operator()(Foo* p) const
    {
        std::cout << "Call delete for Foo object...\n";
        delete p;
    }
};
 
int main()
{
    std::unique_ptr<Foo, D> up(new Foo(), D());
    D& del = up.get_deleter();
    del.bar();
}
//输出：

Foo...
Call deleter D::bar()...
Call delete for Foo object...
~Foo...

3. bool 运算

explicit operator bool() const noexcept;

检查 *this 是否占有对象，即是否有 get() != nullptr。若 *this 占有对象则为 true ，否则为 false 。

#include 
#include 
 
int main()
{
    std::unique_ptr<int> ptr(new int(42));
 
    if (ptr) std::cout << "before reset, ptr is: " << *ptr << '\n';
    ptr.reset();
    if (ptr) std::cout << "after reset, ptr is: " << *ptr << '\n';
}
//输出：

before reset, ptr is: 42