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 <iostream>
#include <vector>
#include <memory>
#include <cstdio>
#include <fstream>
#include <cassert>
#include <functional>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_ptrauto 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 timesstd::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 占有 Dp->bar();} // 调用上述 lambda 并销毁 Dstd::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 <iostream>
#include <memory>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); // 复制 Dstd::unique_ptr<Foo, D> up6b(std::move(up6a)); // 移动 Dstd::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)); // 所有权转移}
#endifstd::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 <iostream>
#include <memory>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 <iostream>
#include <memory>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_ptrp1 = 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 <cassert>
#include <iostream>
#include <memory>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 <iostream>
#include <memory>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 <iostream>
#include <memory>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 <iomanip>
#include <iostream>
#include <memory>
#include <string>
#include <utility>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 <iostream>
#include <memory>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 <iostream>
#include <memory>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