014 《C++ unique_ptr 深度解析：从入门到精通》
🌟🌟🌟本文由Gemini 2.5 Flash Preview 04-17生成，用来辅助学习。🌟🌟🌟
书籍大纲
▮▮ 1. 引言：拥抱现代 C++ 的智能指针
▮▮▮▮ 1.1 手动内存管理的挑战
▮▮▮▮ 1.2 RAII 原则与资源管理
▮▮▮▮ 1.3 智能指针的诞生与发展
▮▮▮▮ 1.4 unique_ptr 概述：独占所有权的智能指针
▮▮ 2. unique_ptr 基础：创建与生命周期管理
▮▮▮▮ 2.1 unique_ptr 的构造与初始化
▮▮▮▮ 2.2 优先使用 std::make_unique
▮▮▮▮ 2.3 作用域与对象的生命周期
▮▮▮▮ 2.4 unique_ptr 的析构行为
▮▮▮▮ 2.5 unique_ptr 的不可拷贝性 (Non-copyable)
▮▮ 3. unique_ptr 所有权的转移：移动语义的应用
▮▮▮▮ 3.1 理解移动语义 (Move Semantics)
▮▮▮▮ 3.2 使用 std::move 转移所有权
▮▮▮▮ 3.3 unique_ptr 作为函数参数和返回值
▮▮▮▮ 3.4 将 unique_ptr 存入标准容器
▮▮▮▮ 3.5 所有权转移的常见场景与注意事项
▮▮ 4. 深入理解 unique_ptr 的机制与高级用法
▮▮▮▮ 4.1 资源操作方法：get(), release(), reset()
▮▮▮▮ 4.2 定制删除器 (Custom Deleter)
▮▮▮▮▮▮ 4.2.1 使用函数指针作为删除器
▮▮▮▮▮▮ 4.2.2 使用函数对象或 Lambda 表达式作为删除器
▮▮▮▮▮▮ 4.2.3 删除器对 unique_ptr 类型和大小的影响
▮▮▮▮ 4.3 unique_ptr 对数组的支持 (unique_ptr
▮▮▮▮ 4.4 其他成员函数：swap(), operator bool, operator*, operator->
▮▮ 5. unique_ptr 与其他指针的比较与选择
▮▮▮▮ 5.1 unique_ptr vs 裸指针 (Raw Pointer)
▮▮▮▮ 5.2 unique_ptr vs auto_ptr (已废弃)
▮▮▮▮ 5.3 unique_ptr vs shared_ptr
▮▮▮▮ 5.4 何时选择 unique_ptr？何时选择 shared_ptr？
▮▮▮▮ 5.5 简述 weak_ptr 与智能指针家族
▮▮ 6. unique_ptr 的最佳实践与设计模式
▮▮▮▮ 6.1 编写异常安全的代码
▮▮▮▮ 6.2 将 unique_ptr 作为工厂函数返回值
▮▮▮▮ 6.3 unique_ptr 与 Pimpl (Pointer to Implementation) 模式
▮▮▮▮ 6.4 在类成员中使用 unique_ptr
▮▮▮▮ 6.5 避免常见的 unique_ptr 错误
▮▮ 7. 性能与注意事项
▮▮▮▮ 7.1 unique_ptr 的性能开销
▮▮▮▮ 7.2 unique_ptr 与异常安全
▮▮▮▮ 7.3 unique_ptr 的线程安全
▮▮▮▮ 7.4 与旧代码的交互：获取裸指针
▮▮ 8. 案例分析与实战应用
▮▮▮▮ 8.1 在数据结构中管理动态对象
▮▮▮▮ 8.2 管理文件句柄或系统资源
▮▮▮▮ 8.3 多态对象的管理
▮▮▮▮ 8.4 模块或插件系统的接口
▮▮ 9. unique_ptr 在 C++ 标准中的演进
▮▮▮▮ 9.1 C++11：unique_ptr 的诞生
▮▮▮▮ 9.2 C++14：std::make_unique 的加入
▮▮▮▮ 9.3 后续标准中的相关改进
▮▮ 附录A: 术语表 (Glossary)
▮▮ 附录B: unique_ptr 关键函数/方法速查
▮▮ 附录C: 常见问题解答 (FAQ)
▮▮ 附录D: 参考文献与进一步阅读 (References and Further Reading)
1. 引言：拥抱现代 C++ 的智能指针
欢迎来到 C++ 智能指针的精彩世界！🚀 在现代 C++ (Modern C++) 的编程实践中，高效且安全的资源管理是构建健壮 (robust)、可靠 (reliable) 应用程序的基石。其中，内存管理 (memory management) 又是资源管理中最核心和最具挑战性的部分之一。C++ 作为一门赋予开发者强大底层控制能力的语言，传统上依赖于手动内存管理，但这常常伴随着棘手的错误。智能指针 (smart pointer) 作为现代 C++ 的重要特性，应运而生，旨在解决这些问题，让资源管理变得更加自动化 (automatic) 和安全 (safe)。
本章将首先回顾手动内存管理所带来的诸多挑战和困境，探讨 C++ 中用于自动资源管理的关键原则——RAII (Resource Acquisition Is Initialization)，然后追溯智能指针的出现背景和演进历程，最终引出本书的主角：std::unique_ptr。我们将初步了解 unique_ptr 的核心概念、独占所有权 (exclusive ownership) 的语义以及它在现代 C++ 中扮演的关键角色。
1.1 手动内存管理的挑战
在 C++ 中，使用 new 运算符在堆 (heap) 上动态分配内存是常见的操作。例如，创建一个动态分配的整数对象：
1
int* raw_ptr = new int;
2
// 使用 raw_ptr ...
3
// 当不再需要时，手动释放内存
4
delete raw_ptr;
虽然这赋予了我们灵活控制对象生命周期的能力，但也带来了显著的风险和负担。开发者必须时刻记住哪些内存在堆上分配了，以及何时何地需要通过 delete 运算符释放它们。一旦遗漏或误操作，就可能导致严重的程序错误。
让我们来看看手动内存管理中常见的几类挑战：
1.1 手动内存管理的挑战
① 内存泄漏 (Memory Leak) 💧
这是最常见的问题之一。当在堆上分配了内存，但在不再使用时忘记或未能成功释放它时，就会发生内存泄漏。随着程序的运行，不断泄露的内存会逐渐耗尽系统的可用内存，导致程序性能下降，甚至崩溃。
例如：
1
void process_data(int size) {
2
int* data = new int[size];
3
// ... 使用 data ...
4
5
// 如果在这里发生异常，或者忘记 delete[] data;
6
// data 指向的内存将永远无法释放，直到程序结束
7
// delete[] data; // <-- 容易遗漏
8
}
在上面的例子中，如果在 delete[] data; 之前抛出了异常，或者函数通过其他方式返回，那么 data 指向的动态分配数组就会发生内存泄漏。
② 重复释放 (Double Free) 💣
重复释放是指对同一块已经被释放的内存再次调用 delete 或 delete[]。这会导致未定义行为 (undefined behavior)，程序可能崩溃，数据被破坏，或者出现其他难以预测的结果。
例如：
1
int* ptr = new int;
2
delete ptr;
3
// ... 其他操作 ...
4
delete ptr; // <-- 错误！ptr 已经被释放，现在指向的是无效内存
③ 野指针 (Dangling Pointer) 💀
野指针是指那些指向已经无效或已被释放内存地址的指针。当原始内存被释放后，如果仍然通过野指针去访问或修改该内存，同样会触发未定义行为，可能导致程序崩溃或数据损坏。
例如：
1
int* ptr1 = new int;
2
int* ptr2 = ptr1; // ptr2 也指向同一块内存
3
4
delete ptr1; // 内存被释放，ptr1 成为野指针
5
// 现在 ptr2 也成为了野指针！
6
// ... 尝试使用 *ptr2 ... // <-- 错误！访问无效内存
④ 资源管理与异常安全 (Exception Safety) 🛡️
当使用手动内存管理时，如果代码中涉及异常处理，那么确保在所有可能的执行路径（包括正常返回和异常抛出）中都能正确释放资源（不仅仅是内存，还包括文件句柄、网络连接等）将变得异常复杂。忘记在 catch 块中释放资源是导致泄漏的常见原因。
⑤ 代码复杂性与维护难度 🚧
随着项目规模的增大，手动跟踪和管理所有动态分配的资源变得越来越困难，容易出错。这增加了代码的复杂性，降低了可读性，并使得后续的维护和重构工作变得更加艰巨。
这些挑战凸显了在现代 C++ 中，一种更自动化、更安全、更符合 RAII 原则的资源管理机制的必要性。智能指针正是为此而生。
1.2 RAII 原则与资源管理
RAII (Resource Acquisition Is Initialization)，中文常翻译为“资源获取即初始化”或“资源在构造时获取，在析构时释放”，是 C++ 中一种重要的编程范式，用于管理生命周期与作用域 (scope) 绑定的资源。
这个原则的核心思想是：
① 将资源的获取（例如，打开文件、申请内存、获取锁等）与一个对象的构造函数 (constructor) 绑定。
② 将资源的释放（例如，关闭文件、释放内存、释放锁等）与同一个对象的析构函数 (destructor) 绑定。
由于 C++ 保证栈 (stack) 上对象的生命周期与它们所在的作用域严格关联，当一个对象离开其作用域时（无论是正常退出，还是由于异常抛出），其析构函数都会被自动调用。利用这一特性，我们就可以确保资源在不再需要时总是能够被可靠地释放。
RAII 的优势在于：
⚝ 自动性 (Automaticity): 资源管理逻辑内嵌在类的构造函数和析构函数中，无需开发者手动调用释放函数。
⚝ 异常安全 (Exception Safety): 无论程序执行路径如何（正常流程或异常抛出），析构函数都能被保证调用，从而防止资源泄漏。
⚝ 封装性 (Encapsulation): 资源管理细节被封装在类的内部，使用者无需关心复杂的释放逻辑。
例如，一个简单的 RAII 类来管理一个动态整数：
1
class IntResource {
2
public:
3
IntResource(int value) : ptr_(new int(value)) {
4
std::cout << "Resource acquired: Allocated int with value " << *ptr_ << std::endl;
5
}
6
7
~IntResource() {
8
if (ptr_) {
9
std::cout << "Resource released: Deleting int with value " << *ptr_ << std::endl;
10
delete ptr_;
11
ptr_ = nullptr; // Good practice to nullify after delete
12
}
13
}
14
15
// Disable copy for simplicity in this example (unique ownership idea)
16
IntResource(const IntResource&) = delete;
17
IntResource& operator=(const IntResource&) = delete;
18
19
// Simple access
20
int getValue() const {
21
return *ptr_;
22
}
23
24
private:
25
int* ptr_;
26
};
27
28
void use_resource() {
29
// 资源获取 (初始化)
30
IntResource res(100);
31
// 使用资源
32
std::cout << "Using resource, value: " << res.getValue() << std::endl;
33
// 作用域结束，res 对象被销毁，其析构函数自动调用，释放资源
34
} // res Goes out of scope here
35
36
int main() {
37
use_resource();
38
// 程序退出，内存已正确释放
39
return 0;
40
}
在这个例子中，IntResource 对象 res 在进入 use_resource 函数的作用域时被创建，动态分配内存。当 use_resource 函数执行完毕，无论正常返回还是有异常，res 对象都会被销毁，其析构函数被调用，自动释放了 new 来的内存。这就是 RAII 的力量！ 💪
智能指针正是 RAII 原则在动态内存管理中的典型应用。它们是包装了裸指针 (raw pointer) 的类模板 (class template)，通过自身的生命周期来管理所指向的动态分配对象的生命周期。
1.3 智能指针的诞生与发展
尽管 RAII 是一个强大的原则，但手动为每一种需要管理的资源都编写一个包装类是繁琐且容易重复工作的。尤其对于动态分配的内存，这是一种非常普遍的需求。因此，标准库 (Standard Library) 提供了通用的 RAII 包装器来简化这一过程，这就是智能指针。
智能指针的出现经历了几个阶段：
① 早期的尝试：std::auto_ptr (C++98/03) 🕰️
在 C++98 标准中引入了 std::auto_ptr，这是 C++ 标准库中的第一个智能指针。它尝试实现一种独占所有权语义，即在任何时间点，只有一个 auto_ptr 对象拥有其指向的资源。然而，auto_ptr 的所有权转移语义非常特殊且具有误导性：拷贝 (copy) 操作会转移所有权，导致源 auto_ptr 变为空指针 (nullptr)。这违反了通常的拷贝语义（拷贝后，源和目标都有效且独立），并且很容易导致难以发现的 bug。例如：
1
#include <memory>
2
3
std::auto_ptr<int> create_int(int value) {
4
return std::auto_ptr<int>(new int(value)); // 所有权在此转移
5
}
6
7
int main() {
8
std::auto_ptr<int> p1(new int(10));
9
std::auto_ptr<int> p2 = p1; // 所有权从 p1 转移到 p2，p1 变空！
10
// std::cout << *p1 << std::endl; // <-- 错误！访问空指针
11
std::cout << *p2 << std::endl; // 输出 10
12
13
std::auto_ptr<int> p3 = create_int(20); // 所有权从函数返回值转移给 p3
14
std::cout << *p3 << std::endl; // 输出 20
15
16
return 0; // p2 和 p3 的析构函数被调用，释放内存
17
}
这种非标准的拷贝行为使得 auto_ptr 难以安全地在 STL 容器中使用，并常常导致混淆和错误。由于其设计缺陷，auto_ptr 在 C++11 中被正式废弃 (deprecated)，并在 C++17 中被彻底移除 (removed)。
② 现代 C++ 智能指针家族 (C++11 及以后) ✨
为了提供更健壮、更灵活的智能指针方案，C++11 引入了全新的智能指针家族，包括：
▮▮▮▮⚝ std::unique_ptr: 独占所有权智能指针。
▮▮▮▮⚝ std::shared_ptr: 共享所有权智能指针，使用引用计数 (reference counting)。
▮▮▮▮⚝ std::weak_ptr: 弱引用智能指针，配合 shared_ptr 使用，用于打破循环引用 (cyclic references)。
这些智能指针基于现代 C++ 的核心特性，如移动语义 (move semantics) 和右值引用 (rvalue references)，提供了更安全、更高效的资源管理方式，并彻底取代了 auto_ptr。它们成为了现代 C++ 中管理动态资源的标准工具。
本書将聚焦于 std::unique_ptr，它是智能指针家族中最基础也是最常使用的一种。
1.4 unique_ptr 概述：独占所有权的智能指针
std::unique_ptr 是 C++11 引入的一种智能指针，旨在解决 auto_ptr 的设计问题，并成为独占所有权资源管理的标准方案。
核心概念：独占所有权 (Exclusive Ownership)
顾名思义，unique_ptr 强调其所拥有的资源是“独一无二”的。在任何时候，一个特定的动态分配对象（或数组）只能由一个 unique_ptr 对象管理。这意味着：
① 不可拷贝 (Non-copyable): unique_ptr 的拷贝构造函数 (copy constructor) 和拷贝赋值运算符 (copy assignment operator) 被显式地删除 (deleted)。你不能像复制普通对象那样复制一个 unique_ptr。
② 可移动 (Moveable): unique_ptr 支持移动语义 (move semantics)。你可以通过移动操作（例如使用 std::move）将一个 unique_ptr 所拥有的资源所有权转移给另一个 unique_ptr。转移后，源 unique_ptr 变为空，而目标 unique_ptr 获得对资源的独占控制权。这种所有权转移是廉价 (cheap) 且安全 (safe) 的。
unique_ptr 的主要特点和解决的问题：
⚝ 自动资源释放: 当 unique_ptr 对象离开其作用域时，其析构函数会自动调用 delete (对于单个对象) 或 delete[] (对于数组) 来释放所管理的内存，彻底解决了内存泄漏的问题（除非你主动干预其所有权管理）。
⚝ 独占性保证: 通过禁止拷贝并强制使用移动语义，unique_ptr 确保了不会发生重复释放的问题，因为资源永远只有一个所有者。
⚝ 低开销 (Low Overhead): unique_ptr 在绝大多数情况下，其运行时开销与裸指针相当。它通常只在栈上占用指针大小的空间，并且在析构时只执行一个 delete 操作。它没有引用计数或其他复杂的内部结构，因此性能很高。
⚝ 管理多种资源: 除了内存，unique_ptr 还可以通过定制删除器 (custom deleter) 来管理其他类型的资源，如文件句柄、互斥锁等，将其生命周期与对象作用域绑定，体现了更广泛的 RAII 应用。
⚝ 清晰的所有权语义: unique_ptr 明确地表达了其所管理的资源的所有权是独占的，这使得代码意图更加清晰，有助于开发者理解和维护代码。
示例：使用 unique_ptr 管理动态内存
1
#include <iostream>
2
#include <memory>
3
4
// 函数返回一个 unique_ptr，转移了所有权
5
std::unique_ptr<int> create_unique_int(int value) {
6
return std::make_unique<int>(value); // C++14 推荐方式
7
} // 返回时发生所有权转移（移动）
8
9
int main() {
10
// 创建一个 unique_ptr，拥有一个动态分配的 int
11
std::unique_ptr<int> ptr1 = std::make_unique<int>(10);
12
std::cout << "ptr1 points to: " << *ptr1 << std::endl;
13
14
// 尝试拷贝会编译错误：
15
// std::unique_ptr<int> ptr2 = ptr1; // <-- 编译错误！unique_ptr 不可拷贝
16
17
// 使用 std::move 转移所有权
18
std::unique_ptr<int> ptr3 = std::move(ptr1);
19
std::cout << "After move, ptr1 is valid? " << (ptr1 != nullptr) << std::endl; // 输出 false
20
std::cout << "ptr3 points to: " << *ptr3 << std::endl; // 输出 10
21
22
// 使用函数返回的 unique_ptr
23
std::unique_ptr<int> ptr4 = create_unique_int(25);
24
std::cout << "ptr4 points to: " << *ptr4 << std::endl;
25
26
// ptr3 和 ptr4 在 main 函数作用域结束时自动释放内存
27
return 0;
28
} // ptr3 and ptr4 go out of scope here, memory is automatically deleted
这个简单的例子展示了 unique_ptr 的创建、独占性（不可拷贝）以及如何使用 std::move 进行所有权转移。
总而言之，unique_ptr 是现代 C++ 中管理独占性资源的首选工具，它提供了一种安全、高效且表达力强的方式来处理动态内存和其他资源，是告别手动内存管理噩梦的重要一步。
接下来的章节中，我们将深入探讨 unique_ptr 的各种用法、机制、与其他智能指针的区别以及在实际编程中的最佳实践。
2. unique_ptr 基础：创建与生命周期管理
在第一章中，我们了解了手动内存管理带来的痛点，以及智能指针作为 RAII（资源获取即初始化 Resource Acquisition Is Initialization）的典型应用，是如何帮助我们规避这些问题的。本章将聚焦于 unique_ptr，它是 C++11 标准库引入的一种智能指针，旨在提供一种安全、高效的方式来管理具有独占所有权（exclusive ownership）的动态分配对象。我们将从 unique_ptr 的创建和初始化开始，深入探讨其如何通过作用域自动管理资源，理解其核心的析构行为，并阐明其“不可拷贝（Non-copyable）”这一关键特性。
2.1 unique_ptr 的构造与初始化
std::unique_ptr 是一个模板类，其声明通常类似于 std::unique_ptr<T>，其中 T 是它所管理的对象类型。它的核心功能是确保在 unique_ptr 对象本身被销毁时，其所指向的动态分配对象也会被自动删除，从而防止内存泄漏（memory leak）。
创建 unique_ptr 有几种主要方式：
① 使用 new 运算符直接构造：
这是最直观的方式，将 new 表达式的结果直接传递给 unique_ptr 的构造函数。
1
#include <memory>
2
#include <iostream>
3
4
class MyClass {
5
public:
6
MyClass() { std::cout << "MyClass constructed!" << std::endl; }
7
~MyClass() { std::cout << "MyClass destructed!" << std::endl; }
8
void greet() const { std::cout << "Hello from MyClass!" << std::endl; }
9
};
10
11
int main() {
12
// 创建一个指向 MyClass 对象的 unique_ptr
13
std::unique_ptr<MyClass> ptr1(new MyClass());
14
15
if (ptr1) { // unique_ptr 可以像普通指针一样进行布尔判断
16
ptr1->greet(); // 使用 -> 运算符访问成员
17
}
18
19
// 当 ptr1 超出作用域时，它会自动删除 MyClass 对象
20
std::cout << "End of main function." << std::endl;
21
return 0;
22
} // ptr1 在这里被销毁
▮▮▮▮注意（Note）：
▮▮▮▮⚝ 使用 new 直接构造 unique_ptr 存在一个潜在的异常安全（exception safety）问题，尤其是在一个表达式中包含多个函数调用和 new 操作时。例如：func(std::unique_ptr<A>(new A()), create_B()); 如果 create_B() 抛出异常，new A() 分配的内存可能在被 unique_ptr 接管之前就发生了泄漏。这促使了 std::make_unique 的出现。
② 使用 std::make_unique (C++14 及以后)：
std::make_unique 是一个 C++14 标准库函数模板，它是一个创建 unique_ptr 的工厂函数。推荐使用 std::make_unique 而不是直接使用 new。
1
#include <memory>
2
#include <iostream>
3
4
class MyClass {
5
public:
6
MyClass() { std::cout << "MyClass constructed!" << std::endl; }
7
~MyClass() { std::cout << "MyClass destructed!" << std::endl; }
8
void greet() const { std::cout << "Hello from MyClass!" << std::endl; }
9
};
10
11
int main() {
12
// 使用 std::make_unique 创建一个指向 MyClass 对象的 unique_ptr
13
// 注意：make_unique 会自动处理 new 调用
14
std::unique_ptr<MyClass> ptr2 = std::make_unique<MyClass>();
15
16
if (ptr2) {
17
ptr2->greet();
18
}
19
20
// 当 ptr2 超出作用域时，它会自动删除 MyClass 对象
21
std::cout << "End of main function." << std::endl;
22
return 0;
23
} // ptr2 在这里被销毁
▮▮▮▮std::make_unique 的语法是 std::make_unique<T>(args...)，其中 T 是要创建的类型，args... 是传递给 T 类型构造函数的参数。
③ 创建一个空的 unique_ptr：
可以创建一个不管理任何资源的 unique_ptr，它包含一个空指针（nullptr）。
1
#include <memory>
2
#include <iostream>
3
4
int main() {
5
// 创建一个空的 unique_ptr
6
std::unique_ptr<int> empty_ptr;
7
8
if (!empty_ptr) { // 检查 unique_ptr 是否为空
9
std::cout << "empty_ptr is null." << std::endl;
10
}
11
12
// 也可以通过 nullptr 初始化
13
std::unique_ptr<double> empty_ptr2 = nullptr;
14
15
// 之后可以赋值一个新创建的对象给它
16
empty_ptr = std::make_unique<int>(100);
17
if (empty_ptr) {
18
std::cout << "empty_ptr now points to: " << *empty_ptr << std::endl;
19
}
20
21
std::cout << "End of main function." << std::endl;
22
return 0;
23
} // empty_ptr 和 empty_ptr2 在这里被销毁
④ 从裸指针（raw pointer）获取所有权：
虽然不推荐直接使用 new 后再构造 unique_ptr，但在某些特定场景下，你可能需要让 unique_ptr 接管一个已存在的裸指针所指向的资源。这通常用于与旧的 C++ 代码或 C 风格 API 交互。
1
#include <memory>
2
#include <iostream>
3
4
int main() {
5
int* raw_ptr = new int(42);
6
std::cout << "Raw pointer created." << std::endl;
7
8
// unique_ptr 接管 raw_ptr 的所有权
9
std::unique_ptr<int> managed_ptr(raw_ptr); // explicit 构造函数
10
11
std::cout << "Managed pointer value: " << *managed_ptr << std::endl;
12
13
// 现在不应该再使用 raw_ptr 了，因为 managed_ptr 拥有其所有权
14
15
std::cout << "End of main function." << std::endl;
16
return 0;
17
} // managed_ptr 在这里被销毁，并调用 delete raw_ptr;
▮▮▮▮重要提示（Important Note）：
▮▮▮▮⚝ 一旦 unique_ptr 接管了裸指针的所有权，你绝对不应该再通过这个裸指针或任何其他方式手动释放或管理这个资源。所有权已经转移给 unique_ptr，它的生命周期将负责资源的释放。
2.2 优先使用 std::make_unique
正如在讨论直接使用 new 构造 unique_ptr 时提到的，std::make_unique (C++14 及以后版本提供) 是创建 unique_ptr 的首选方式。其主要优势体现在以下几个方面：
① 异常安全（Exception Safety）：
这是 std::make_unique 最重要的优势之一。考虑以下（不安全的）代码：
1
// 存在异常安全问题的代码示例（应避免）
2
void process_pointers(std::unique_ptr<Resource> ptr1, std::unique_ptr<OtherResource> ptr2);
3
4
// 在 C++11 中可能这样写（存在异常安全问题）
5
process_pointers(std::unique_ptr<Resource>(new Resource()), std::unique_ptr<OtherResource>(new OtherResource()));
在评估函数参数时，编译器可能会以不确定的顺序执行子表达式。例如，它可能先执行 new Resource()，然后执行 new OtherResource()，最后再调用两个 unique_ptr 的构造函数。如果在执行完 new Resource() 后，但在 std::unique_ptr<Resource> 构造函数被调用接管裸指针之前，new OtherResource() 抛出了异常，那么 new Resource() 分配的内存将永远不会被 unique_ptr 管理，从而导致内存泄漏。
而使用 std::make_unique 则可以避免这个问题：
1
// 使用 std::make_unique，保证异常安全
2
process_pointers(std::make_unique<Resource>(), std::make_unique<OtherResource>());
std::make_unique 函数内部会先执行 new Resource()（或 new OtherResource()），然后立即将结果传递给 unique_ptr 的构造函数。这是一个原子操作（相对于外部表达式求值顺序而言）。如果在 make_unique 内部的 new 调用后、unique_ptr 构造前发生异常，这是不可能的；如果在调用 make_unique 本身之前或之后发生异常，资源则不会被分配，也就不存在泄漏。
② 代码简洁性（Code Conciseness）：
std::make_unique 的语法更短，避免了类型冗余。
1
// 使用 new: 类型重复
2
std::unique_ptr<MyClass> ptr1(new MyClass(arg1, arg2));
3
4
// 使用 make_unique: 类型只需写一次
5
std::unique_ptr<MyClass> ptr2 = std::make_unique<MyClass>(arg1, arg2);
③ 性能优化：
在某些情况下，特别是当对象构造函数需要多个参数时，std::make_unique 可以通过一次内存分配同时为对象及其智能指针的内部状态（尽管 unique_ptr 的内部状态非常小，但这对于 shared_ptr 的 std::make_shared 更为重要）分配内存，从而可能带来轻微的性能提升。对于 unique_ptr，主要优化在于构造函数参数可以直接完美转发（perfect forward）给对象的构造函数，避免了潜在的拷贝或移动操作。
④ 支持变长参数模板（Variadic Templates）：
std::make_unique 可以直接接受任意数量和类型的参数，并将它们完美转发给被创建对象的构造函数，这使得创建带有复杂构造函数的对象变得非常方便。
1
class ComplexObject {
2
public:
3
ComplexObject(int a, double b, const std::string& s) {
4
std::cout << "ComplexObject constructed with: " << a << ", " << b << ", " << s << std::endl;
5
}
6
};
7
8
// ... 在某个函数中
9
auto complex_ptr = std::make_unique<ComplexObject>(10, 3.14, "hello");
总结: 除非你有非常特殊的理由（例如需要使用定制删除器，这在 std::make_unique 中需要 C++20 或更高版本支持，或者需要从一个已存在的裸指针接管所有权），否则总是优先使用 std::make_unique 来创建 unique_ptr。
2.3 作用域与对象的生命周期
unique_ptr 的核心功能是自动管理其所指向资源的生命周期。它是 RAII 原则在 C++ 内存管理中的一个经典应用。
RAII (Resource Acquisition Is Initialization) 的核心思想是：将资源的生命周期与一个对象的生命周期绑定。当这个对象被创建（初始化）时，资源被获取；当这个对象被销毁时（无论是因为正常流程结束、抛出异常还是其他原因），资源被自动释放。
在 C++ 中，局部对象的生命周期严格遵循其所在的作用域（scope）。当一个局部对象所在的块作用域（block scope，即一对花括号 {} 括起来的区域）结束时，该局部对象的析构函数（destructor）会被自动调用。
std::unique_ptr 正是利用了这一机制。当一个 unique_ptr 对象（它本身通常是栈上分配的局部对象）被创建并管理一个堆上的资源（例如通过 new 分配的内存）时：
① 资源获取：unique_ptr 在构造时接收一个指向堆上资源的裸指针，从而“获取”了该资源的所有权。
② 资源释放：当 unique_ptr 对象所在的作用域结束时，unique_ptr 的析构函数会自动执行。在其析构函数内部，unique_ptr 会调用 delete 运算符（或定制的删除器，详见后续章节）来释放它所管理的堆上资源。
1
#include <memory>
2
#include <iostream>
3
4
class Resource {
5
public:
6
Resource() { std::cout << "Resource acquired." << std::endl; }
7
~Resource() { std::cout << "Resource released." << std::endl; }
8
};
9
10
void func() {
11
std::cout << "Entering func()." << std::endl;
12
// 在 func() 的作用域内创建一个 unique_ptr
13
std::unique_ptr<Resource> res_ptr = std::make_unique<Resource>();
14
// res_ptr 管理一个 Resource 对象
15
16
std::cout << "Leaving func()." << std::endl;
17
// 当 func() 函数结束时，res_ptr 超出作用域
18
// res_ptr 的析构函数被调用，自动释放 Resource 对象
19
} // res_ptr 在这里被销毁
20
21
int main() {
22
std::cout << "Entering main()." << std::endl;
23
func();
24
std::cout << "Leaving main()." << std::endl;
25
return 0;
26
}
▮▮▮▮运行上述代码，输出将是：
1
Entering main().
2
Entering func().
3
Resource acquired.
4
Leaving func().
5
Resource released.
6
Leaving main().
这清晰地展示了 Resource 对象的构造（资源获取）发生在 unique_ptr 创建时，而析构（资源释放）发生在 unique_ptr 离开其作用域时。
这种基于作用域的自动资源管理机制，极大地简化了内存管理，消除了因忘记 delete 而导致的内存泄漏，同时也提高了代码的异常安全性，因为无论代码如何退出当前作用域（正常执行结束或异常抛出），局部对象的析构函数都会被调用，确保资源被正确清理。
2.4 unique_ptr 的析构行为
unique_ptr 最核心的功能体现在其析构函数中。当一个 unique_ptr 对象被销毁时，它的析构函数会检查它当前是否管理着一个非空的指针。如果管理着一个非空指针，它就会调用其内部存储的删除器（deleter）来释放该指针所指向的资源。
① 默认删除器（Default Deleter）：
对于 std::unique_ptr<T>（非数组类型），默认的删除器是调用 delete 运算符。
对于 std::unique_ptr<T[]>（数组类型），默认的删除器是调用 delete[] 运算符。
1
#include <memory>
2
#include <iostream>
3
4
class MyObject {
5
public:
6
MyObject(int id) : id_(id) { std::cout << "MyObject " << id_ << " constructed." << std::endl; }
7
~MyObject() { std::cout << "MyObject " << id_ << " destructed." << std::endl; }
8
private:
9
int id_;
10
};
11
12
int main() {
13
{ // 第一个作用域
14
std::cout << "Entering first scope." << std::endl;
15
std::unique_ptr<MyObject> obj_ptr = std::make_unique<MyObject>(1);
16
std::cout << "Leaving first scope." << std::endl;
17
} // obj_ptr 在这里被销毁，其默认删除器调用 delete obj_ptr.get();
18
19
std::cout << std::endl;
20
21
{ // 第二个作用域，使用数组类型
22
std::cout << "Entering second scope (array)." << std::endl;
23
// unique_ptr<MyObject[]> 管理一个 MyObject 数组
24
std::unique_ptr<MyObject[]> obj_array_ptr = std::make_unique<MyObject[]>(3);
25
// 注意：make_unique 对数组类型的语法略有不同，只指定元素数量
26
// 在 C++14 之前，创建 unique_ptr<T[]> 需要手动使用 new[]:
27
// std::unique_ptr<MyObject[]> obj_array_ptr_old(new MyObject[3]);
28
29
std::cout << "Leaving second scope (array)." << std::endl;
30
} // obj_array_ptr 在这里被销毁，其默认删除器调用 delete[] obj_array_ptr.get();
31
32
std::cout << "\nEnd of main function." << std::endl;
33
return 0;
34
}
运行结果将清晰地展示对象的构造和析构顺序，验证了默认删除器的行为。对于数组类型，delete[] 会负责调用数组中每个元素的析构函数。
② 定制删除器（Custom Deleter）：
除了默认的 delete 和 delete[]，unique_ptr 还允许你指定一个定制的删除器。这是一个非常强大的功能，它使得 unique_ptr 不仅可以管理堆上的内存，还可以管理其他类型的资源，如文件句柄、网络套接字、数据库连接等。我们将在第四章中详细探讨定制删除器的用法。
③ 析构时的注意事项：
⚝ 如果 unique_ptr 管理的指针是 nullptr，析构函数不会执行任何操作。
⚝ 析构行为是自动的，无需手动干预。这是 RAII 的核心优势。
⚝ 如果通过 release() 方法放弃了所有权（详见第四章），unique_ptr 的析构函数也不会删除资源。
理解 unique_ptr 的析构行为对于正确使用它至关重要。它是实现自动资源管理和异常安全性的基石。
2.5 unique_ptr 的不可拷贝性 (Non-copyable)
unique_ptr 被设计为管理具有独占所有权（exclusive ownership）的资源。这意味着在任何时候，一个特定的资源只能被一个 unique_ptr 对象管理。这种独占性是通过禁止 unique_ptr 的拷贝（copy）来实现的。
一个 unique_ptr 不能通过拷贝构造函数（copy constructor）或拷贝赋值运算符（copy assignment operator）来创建其副本或进行赋值。在 std::unique_ptr 的定义中，这些成员函数被显式地标记为 = delete。
1
#include <memory>
2
#include <iostream>
3
4
class MyResource {
5
public:
6
MyResource() { std::cout << "Resource acquired." << std::endl; }
7
~MyResource() { std::cout << "Resource released." << std::endl; }
8
};
9
10
int main() {
11
std::unique_ptr<MyResource> ptr1 = std::make_unique<MyResource>();
12
13
// 以下代码会导致编译错误！
14
// std::unique_ptr<MyResource> ptr2 = ptr1; // 拷贝构造
15
// std::unique_ptr<MyResource> ptr3;
16
// ptr3 = ptr1; // 拷贝赋值
17
18
std::cout << "End of main function." << std::endl;
19
return 0;
20
}
这种“不可拷贝”的特性是 unique_ptr 独占所有权的直接体现。如果允许拷贝，那么两个或多个 unique_ptr 将会指向同一个资源。当其中一个 unique_ptr 被销毁时，它会释放资源；而当其他 unique_ptr 随后也被销毁时，它们将尝试释放已经被释放的同一块内存，这会导致重复释放（double free）的严重错误，通常表现为程序崩溃或不可预测的行为。
unique_ptr 的设计确保了这种情况永远不会发生。资源的所有权是唯一的，它要么属于某个 unique_ptr，要么不属于任何 unique_ptr（即 unique_ptr 为空）。
虽然 unique_ptr 不可拷贝，但它是可移动（Movable）的。C++11 引入的移动语义（move semantics）正是为了解决这种独占资源的转移问题。通过移动，资源的所有权可以从一个 unique_ptr 安全地转移给另一个 unique_ptr，而不会创建资源的副本。转移后，原来的 unique_ptr 将不再拥有资源（变为空），新的 unique_ptr 则获得了所有权。我们将在下一章详细探讨 unique_ptr 的移动语义。
总而言之，unique_ptr 的不可拷贝性是其“独占所有权”契约的核心组成部分，它通过编译时错误防止了重复释放等潜在的运行时问题，是实现安全资源管理的关键特性。
3. unique_ptr 所有权的转移：移动语义的应用
欢迎回到我们的 C++ 智能指针深度解析课程。在上一章，我们探讨了 unique_ptr 的基本创建、生命周期管理以及其核心的“独占所有权（exclusive ownership）”概念。unique_ptr 最显著的特性之一是它不允许复制，因为复制行为会违反独占所有权原则。然而，在实际编程中，我们经常需要在不同的 unique_ptr 实例之间转移所管理资源的所有权。这就是 C++11 引入的“移动语义（Move Semantics）”发挥作用的地方。
本章将深入探讨 unique_ptr 如何利用移动语义实现所有权的转移，从而在保证安全性的同时，实现资源的灵活管理。我们将学习如何使用 std::move 进行显式转移，理解 unique_ptr 作为函数参数和返回值时的行为，以及如何将 unique_ptr 存储在标准容器中。
3.1 理解移动语义 (Move Semantics)
在深入 unique_ptr 的所有权转移之前，我们有必要简要回顾一下 C++11 引入的核心概念：移动语义。
在 C++11 之前，当我们处理资源密集型对象（如包含大量数据的容器或管理堆内存的对象）时，对象的复制（copy）操作可能会非常昂贵，因为它通常涉及深拷贝（deep copy），即复制对象的所有成员以及其所管理的资源本身。对于某些只需要临时使用的对象，或者源对象即将销毁的情况，这种昂贵的复制是低效甚至不必要的。
移动语义旨在解决这个问题，它允许“窃取”临时对象或明确标记为可移动对象（右值，rvalue）的资源，而不是进行深拷贝。这个过程通常涉及将源对象的内部资源指针或句柄直接转移给目标对象，然后将源对象置于一个有效的、可析构的状态，但不再拥有这些资源。这样，资源本身没有被复制，只是一些指针或内部状态被转移，从而大大提高了效率。
移动语义通过两种新的成员函数来实现：
⚝ 移动构造函数（move constructor）
⚝ 移动赋值运算符（move assignment operator）
这些函数接收一个右值引用（rvalue reference，&&）参数，表示它们可以从一个临时对象或通过 std::move 转换为右值引用的对象那里“移动”资源。
对于 unique_ptr 而言，由于其设计目标是独占所有权，它不允许复制，但它支持移动。unique_ptr 的移动构造函数和移动赋值运算符被定义为能够从另一个 unique_ptr 实例那里转移所有权。当一个 unique_ptr 被移动时，源 unique_ptr 会被置为空（即不再管理任何资源），而目标 unique_ptr 则接管了对资源的独占所有权。这种“转移所有权”的行为正是通过移动语义实现的。
总而言之，移动语义为 C++ 提供了一种高效转移资源的方式，而 unique_ptr 正是利用了这一机制来实现其独特的独占所有权转移。理解移动语义对于正确使用 unique_ptr 进行所有权管理至关重要。
3.2 使用 std::move 转移所有权
unique_ptr 的核心特性是不可复制，这意味着你不能像普通对象那样简单地通过赋值或拷贝构造来创建一个新的 unique_ptr 并让它拥有与源 unique_ptr 相同的资源。例如，以下代码是不允许的：
1
#include <memory>
2
3
int main() {
4
std::unique_ptr<int> ptr1(new int(10));
5
// std::unique_ptr<int> ptr2 = ptr1; // 错误：unique_ptr 不可拷贝
6
// std::unique_ptr<int> ptr3;
7
// ptr3 = ptr1; // 错误：unique_ptr 不可赋值
8
return 0;
9
}
但是，unique_ptr 提供了移动构造函数和移动赋值运算符。这意味着你可以通过“移动”来转移所有权。标准库提供了 std::move 函数来帮助我们显式地表达“我打算移动这个对象，即使它当前是一个左值（lvalue）”。
std::move(obj) 本身并不执行任何移动操作。它只是一个模板函数，其作用是将参数 obj 无条件地转换为一个右值引用。这个右值引用然后可以用于调用对象的移动构造函数或移动赋值运算符（如果存在）。
使用 std::move 转移 unique_ptr 所有权的语法如下：
1
#include <memory>
2
#include <iostream>
3
4
int main() {
5
std::unique_ptr<int> ptr1(new int(10)); // ptr1拥有资源
6
std::cout << "ptr1 指向的值: " << *ptr1 << std::endl;
7
8
// 使用 std::move 转移所有权
9
std::unique_ptr<int> ptr2 = std::move(ptr1); // 调用移动构造函数
10
11
// 转移后，ptr1 变为空
12
if (!ptr1) {
13
std::cout << "ptr1 现在为空" << std::endl;
14
}
15
16
// ptr2 现在拥有资源
17
std::cout << "ptr2 指向的值: " << *ptr2 << std::endl;
18
19
// 再次转移所有权
20
std::unique_ptr<int> ptr3;
21
ptr3 = std::move(ptr2); // 调用移动赋值运算符
22
23
// 转移后，ptr2 变为空
24
if (!ptr2) {
25
std::cout << "ptr2 现在为空" << std::endl;
26
}
27
28
// ptr3 现在拥有资源
29
std::cout << "ptr3 指向的值: " << *ptr3 << std::endl;
30
31
// ptr1, ptr2 都为空，ptr3 在作用域结束时释放资源
32
return 0;
33
}
输出示例：
1
ptr1 指向的值: 10
2
ptr1 现在为空
3
ptr2 指向的值: 10
4
ptr2 现在为空
5
ptr3 指向的值: 10
这个例子清晰地展示了所有权的转移过程：资源最初由 ptr1 拥有，通过 std::move(ptr1) 被转移给了 ptr2，此时 ptr1 变为空；接着，资源又通过 std::move(ptr2) 被转移给了 ptr3，此时 ptr2 变为空。最终，只有 ptr3 拥有对动态分配整数的所有权，并在 main 函数结束时负责释放它。
重要注意事项：
⚝ std::move(obj) 并不会移动对象 obj 本身，它只是将 obj 转换为一个右值引用。实际的移动操作（调用移动构造函数或移动赋值运算符）是由编译器根据这个右值引用来决定的。
⚝ 在一个 unique_ptr 对象被 std::move 后，它将处于一个“已移动（moved-from）”的状态。对于 unique_ptr，这个状态是明确的：它变为空指针（nullptr），不再管理任何资源。你应该避免在使用 std::move 后再通过 * 或 -> 访问源 unique_ptr 所指向的对象，因为此时它已经不拥有任何对象了。你可以安全地对其进行赋值、析构或再次 std::move。
⚝ std::move 主要用于显式地从左值进行移动。对于临时的右值（比如函数的返回值），编译器通常会自动应用移动语义（如果对象支持），而无需显式使用 std::move（参见下一节）。
通过 std::move，我们可以在需要转移所有权但又不能复制的情况下，安全、高效地将 unique_ptr 管理的资源从一个地方移到另一个地方。
3.3 unique_ptr 作为函数参数和返回值
unique_ptr 的移动语义使得它非常适合在函数之间传递所有权。这是一种比通过裸指针传递更安全的方式，因为它明确地表达了资源的归属权转移。
3.3.1 作为函数参数
你可以通过值传递 unique_ptr 作为函数的参数。由于 unique_ptr 不可拷贝，通过值传递时会调用其移动构造函数，从而将所有权转移到函数参数中。一旦函数返回，这个参数（局部的 unique_ptr 对象）就会被销毁，其拥有的资源也会被释放。这适用于你想将资源的生命周期限定在函数内部，或者函数需要接管资源的控制权并最终释放它的场景。
1
#include <memory>
2
#include <iostream>
3
4
void process_resource(std::unique_ptr<int> ptr) {
5
// 现在 unique_ptr 的所有权转移到了函数内部的 ptr
6
if (ptr) {
7
std::cout << "在函数内部处理资源: " << *ptr << std::endl;
8
}
9
// 函数返回时，ptr 超出作用域，资源被释放
10
} // 资源在这里被释放
11
12
int main() {
13
std::unique_ptr<int> main_ptr(new int(20));
14
std::cout << "调用函数前，main_ptr 指向的值: " << *main_ptr << std::endl;
15
16
// 将 main_ptr 的所有权转移给 process_resource 函数
17
// 需要使用 std::move，因为 main_ptr 是一个左值
18
process_resource(std::move(main_ptr));
19
20
// 调用函数后，main_ptr 变为空
21
if (!main_ptr) {
22
std::cout << "调用函数后，main_ptr 现在为空" << std::endl;
23
}
24
25
// 试图访问 main_ptr 将导致未定义行为
26
// std::cout << *main_ptr << std::endl; // 危险！
27
28
return 0;
29
}
输出示例：
1
调用函数前，main_ptr 指向的值: 20
2
在函数内部处理资源: 20
3
调用函数后，main_ptr 现在为空
注意： 如果你只是想让函数使用 unique_ptr 所管理的资源，而不是转移所有权，你应该通过引用（const 引用或非 const 引用）或裸指针传递。通过引用传递 unique_ptr 本身是很常见的，比如 void use_resource(const std::unique_ptr<int>& ptr)。
3.3.2 作为函数返回值
将 unique_ptr 作为函数返回值是实现“工厂函数（Factory Function）”模式的推荐方式。工厂函数负责创建对象并在创建后将新对象的独占所有权交给调用者。
当一个函数按值返回一个 unique_ptr 时，即使没有显式使用 std::move，编译器也通常会应用移动语义（通过返回值优化 RVO 或命名返回值优化 NRVO，如果条件允许；或者如果不能应用 RVO/NRVO，则会调用移动构造函数）。这是因为函数返回的对象被视为一个临时对象（右值）。
1
#include <memory>
2
#include <iostream>
3
4
// 工厂函数，创建对象并返回其 unique_ptr
5
std::unique_ptr<int> create_resource(int value) {
6
// 在函数内部创建资源
7
std::unique_ptr<int> local_ptr(new int(value));
8
std::cout << "在工厂函数内部创建资源，值为: " << *local_ptr << std::endl;
9
10
// 返回 local_ptr。这里通常会发生移动（RVO/NRVO 或移动构造）
11
return local_ptr; // 或者直接 return std::unique_ptr<int>(new int(value));
12
} // local_ptr 所有权转移，不会在这里释放资源
13
14
int main() {
15
// 调用工厂函数，接收 unique_ptr 的所有权
16
std::unique_ptr<int> main_ptr = create_resource(30); // 接收返回值，通常是移动构造
17
18
// main_ptr 现在拥有资源
19
if (main_ptr) {
20
std::cout << "在 main 函数中接收资源，值为: " << *main_ptr << std::endl;
21
}
22
23
// main_ptr 在作用域结束时释放资源
24
return 0;
25
}
输出示例：
1
在工厂函数内部创建资源，值为: 30
2
在 main 函数中接收资源，值为: 30
这个例子中，create_resource 函数创建了一个 int 对象，并将其所有权封装在 local_ptr 中返回。在 main 函数中，main_ptr 通过移动语义（很可能是 NRVO）接收了这个所有权。资源从函数内部安全地转移到了函数外部，并最终由 main_ptr 在其生命周期结束时负责释放。
通过值传递和返回 unique_ptr 是在函数之间安全、高效地转移资源所有权的现代 C++ 方式。它清晰地表达了意图，并利用了编译器的优化和移动语义的效率。
3.4 将 unique_ptr 存入标准容器
将动态创建的对象存储在标准容器（如 std::vector, std::list, std::map 等）中是非常常见的需求。使用裸指针存储对象会导致内存管理的复杂性。std::vector<T*> 需要你手动管理每个 T* 指向的对象的生命周期，这很容易出错。
使用 unique_ptr 可以在容器中安全地存储动态分配的对象，同时让容器负责管理这些对象的生命周期。由于 unique_ptr 不可拷贝，这意味着你不能简单地 push_back(ptr) 如果 ptr 是一个左值 unique_ptr。你需要使用移动语义将 unique_ptr 放入容器。
1
#include <memory>
2
#include <vector>
3
#include <iostream>
4
#include <string>
5
6
class MyClass {
7
std::string name_;
8
public:
9
MyClass(std::string name) : name_(name) {
10
std::cout << "MyClass " << name_ << " created." << std::endl;
11
}
12
~MyClass() {
13
std::cout << "MyClass " << name_ << " destroyed." << std::endl;
14
}
15
const std::string& getName() const { return name_; }
16
};
17
18
int main() {
19
// 创建一个存储 unique_ptr 的 vector
20
std::vector<std::unique_ptr<MyClass>> objects;
21
22
// 创建 unique_ptr 并移动到 vector 中
23
std::unique_ptr<MyClass> obj1 = std::make_unique<MyClass>("One");
24
objects.push_back(std::move(obj1)); // 使用 std::move 将 obj1 移入 vector
25
26
// 直接创建临时 unique_ptr 并移入 vector
27
// make_unique 的返回值是右值，可以直接被 move 到容器中
28
objects.push_back(std::make_unique<MyClass>("Two"));
29
30
// 也可以在循环中创建并添加
31
for (int i = 3; i <= 5; ++i) {
32
objects.push_back(std::make_unique<MyClass>("Number " + std::to_string(i)));
33
}
34
35
// obj1 现在是空的
36
if (!obj1) {
37
std::cout << "obj1 现在为空." << std::endl;
38
}
39
40
std::cout << "\n遍历 vector 中的对象:" << std::endl;
41
// 遍历容器，访问对象
42
for (const auto& ptr : objects) {
43
if (ptr) { // 检查指针是否有效 (通常是有效的，除非被移出)
44
std::cout << " 对象名称: " << ptr->getName() << std::endl;
45
}
46
}
47
std::cout << std::endl;
48
49
// 容器销毁时，会自动销毁其包含的所有 unique_ptr
50
// 每个 unique_ptr 销毁时会释放其管理的 MyClass 对象
51
std::cout << "main 函数结束，vector 将被销毁，释放所有对象..." << std::endl;
52
53
return 0;
54
} // vector<unique_ptr> 在这里销毁，触发 MyClass 析构
输出示例（顺序可能略有不同，取决于具体实现和优化）：
1
MyClass One created.
2
obj1 现在为空.
3
MyClass Two created.
4
MyClass Number 3 created.
5
MyClass Number 4 created.
6
MyClass Number 5 created.
7
8
遍历 vector 中的对象:
9
对象名称: One
10
对象名称: Two
11
对象名称: Number 3
12
对象名称: Number 4
13
对象名称: Number 5
14
15
main 函数结束，vector 将被销毁，释放所有对象...
16
MyClass One destroyed.
17
MyClass Two destroyed.
18
MyClass Number 3 destroyed.
19
MyClass Number 4 destroyed.
20
MyClass Number 5 destroyed.
从输出可以看出，对象在被添加到容器时创建，并在容器 objects 生命周期结束时（即 main 函数返回前）被正确地销毁。这极大地简化了动态创建对象集合时的内存管理。
重要概念：
⚝ std::vector 等标准容器在需要复制元素时（例如，插入到中间、扩容时），会尝试使用元素的拷贝构造函数或拷贝赋值运算符。由于 unique_ptr 不可拷贝，包含 unique_ptr 的容器在执行这类操作时，也必须使用元素的移动构造函数或移动赋值运算符。这意味着某些容器操作（如 vector::insert 到非末尾位置）可能需要 unique_ptr 具备移动能力（这没问题），但不支持需要拷贝语义的操作。
⚝ 在遍历容器时，通常使用 const auto& 或 auto& 引用来避免不必要的所有权转移。如果你需要从容器中取出并转移某个 unique_ptr 的所有权，可以使用 std::move(objects[i]) 或迭代器配合 std::move(*it)。
将 unique_ptr 存储在标准容器中是现代 C++ 中管理动态对象集合的标准做法，它结合了容器的便利性和 unique_ptr 的安全性与效率。
3.5 所有权转移的常见场景与注意事项
理解 unique_ptr 的所有权转移后，我们来看看它在实际编程中的一些常见应用场景以及使用时需要注意的事项。
3.5.1 常见场景
① 工厂函数返回值： 如前所述，工厂函数负责创建复杂对象，并将其唯一所有权交给调用者。返回 std::unique_ptr<T> 是最自然和安全的方式。
1
// 场景：创建不同类型的游戏怪物对象
2
class Monster { /* ... */ };
3
class Goblin : public Monster { /* ... */ };
4
class Ogre : public Monster { /* ... */ };
5
6
std::unique_ptr<Monster> create_monster(const std::string& type) {
7
if (type == "goblin") {
8
return std::make_unique<Goblin>();
9
} else if (type == "ogre") {
10
return std::make_unique<Ogre>();
11
}
12
return nullptr; // 或抛出异常
13
} // 返回 unique_ptr 转移所有权
② 对象成员管理动态资源： 一个类可能需要动态分配一个子对象或资源，并且这个资源由该类的实例独占。在这种情况下，使用 std::unique_ptr 作为类成员变量是理想的选择。当类对象被移动时，其 unique_ptr 成员也会被移动，从而转移了子对象的所有权。当类对象销毁时，其 unique_ptr 成员也会销毁，释放子对象。
1
// 场景：一个拥有专属配置对象的类
2
class Config { /* ... */ };
3
4
class Application {
5
std::unique_ptr<Config> config_; // 独占配置对象
6
public:
7
Application(std::unique_ptr<Config> cfg) : config_(std::move(cfg)) { // 通过移动接收所有权
8
// ...
9
}
10
// Application 自动支持移动语义，因为其成员 unique_ptr 支持移动
11
// Application 的拷贝构造函数/赋值运算符将被禁用（default），因为 unique_ptr 不可拷贝
12
// ...
13
};
③ 局部资源管理并移出： 在函数内部创建临时资源，并在函数结束前将其所有权移出给调用者或另一个对象。
1
// 场景：一个函数内部处理一些数据并生成一个结果对象返回
2
std::unique_ptr<Result> process_data(const Data& data) {
3
auto temp_result = std::make_unique<Result>();
4
// ... 对 temp_result 进行处理 ...
5
return temp_result; // 所有权移出
6
}
④ 标准容器元素的管理： 如前一节所述，在容器中存储动态创建的对象集合。
⑤ Pimpl (Pointer to Implementation) 模式： 使用 unique_ptr 来指向类的私有实现细节，隐藏实现并减少头文件依赖。这通常需要定制删除器来处理不完全类型（incomplete type）。我们会在后续章节更详细讨论。
3.5.2 注意事项与潜在错误
① 不要在 std::move 后使用源 unique_ptr： 这是一个常见的错误。std::move 后源 unique_ptr 变为空，通过它访问资源会导致未定义行为（通常是崩溃）。
1
std::unique_ptr<int> ptr1(new int(10));
2
std::unique_ptr<int> ptr2 = std::move(ptr1);
3
// std::cout << *ptr1 << std::endl; // 错误！ptr1 现在为空
② 理解 std::move 只是一个转换： 它本身不执行移动。实际执行移动的是目标对象的移动构造函数或移动赋值运算符。如果目标对象没有合适的移动函数，std::move 可能会导致编译错误，或者（在极少数情况下）退化为拷贝（对于 unique_ptr 这是不可能的，因为它禁用了拷贝）。
③ 避免不必要的 std::move： 对于函数的返回值（临时对象），编译器通常会自动处理移动。显式使用 std::move 通常是不必要的，有时甚至会抑制返回值优化（RVO/NRVO），反而可能降低效率（尽管现代编译器在这方面做得越来越好）。只在需要从左值强制进行移动时才使用 std::move。
1
std::unique_ptr<int> create_int(int value) {
2
std::unique_ptr<int> p(new int(value));
3
return p; // 通常不需要 std::move(p)
4
}
5
6
// 调用时，编译器通常会直接在 main_ptr 的位置构造对象（NRVO）
7
// 或者从 create_int 的临时返回值移动过来
8
std::unique_ptr<int> main_ptr = create_int(40);
④ 容器操作与所有权： 当对包含 unique_ptr 的容器进行操作时，要清楚哪些操作会转移所有权（如 push_back 一个 rvalue unique_ptr，std::move 一个元素到另一个位置），哪些操作会销毁元素（如 pop_back, erase, 容器自身销毁）。避免在不小心的情况下丢失对资源的唯一引用。
⑤ 异常安全： unique_ptr 在所有权转移过程中天然是异常安全的。移动操作本身通常不抛异常，即使抛异常，源对象要么成功转移变为空，要么未转移保持原样，不会导致资源泄露。这是相对于裸指针的一大优势。
掌握 unique_ptr 的所有权转移及其与移动语义的关系，是高效和安全地使用 unique_ptr 的关键。通过 std::move 在需要时进行显式转移，并通过函数参数/返回值和容器隐式或显式转移，可以灵活地控制资源的生命周期。
4. 深入理解 unique_ptr 的机制与高级用法
本章将带领读者深入了解 std::unique_ptr 的底层机制和一些更高级的用法。我们将探讨如何通过 get(), release(), 和 reset() 等成员函数直接或间接操作底层资源，如何使用定制删除器 (custom deleter) 来管理非内存资源或实现特殊的清理逻辑，以及 unique_ptr 如何支持对动态分配的数组进行安全管理。此外，我们还将介绍 unique_ptr 的其他重要成员函数，如 swap(), operator bool, operator*, 和 operator->。掌握这些高级用法，将使您能够更灵活、更强大地利用 unique_ptr 进行资源管理。
4.1 资源操作方法：get(), release(), reset()
std::unique_ptr 除了通过其生命周期利用 RAII 原则自动管理资源外，还提供了一些成员函数，允许开发者在特定场景下与它所管理的底层资源（通常是裸指针）进行交互。这些方法包括 get(), release(), 和 reset()。理解它们的用途和潜在风险对于正确使用 unique_ptr 至关重要。
4.1.1 get() 方法：获取底层裸指针
get() 方法返回 unique_ptr 内部管理的原始指针 (raw pointer)。
⚝ 目的 (Purpose):
▮▮▮▮⚝ 主要用于与那些需要裸指针作为参数的 C 风格或旧版 C++ API 进行交互。
▮▮▮▮⚝ 可以用来检查 unique_ptr 是否持有资源（即 get() != nullptr），尽管使用 operator bool 通常更推荐。
⚝ 用法 (Usage):
1
#include <memory>
2
#include <iostream>
3
4
void process_raw_pointer(int* p) {
5
if (p) {
6
std::cout << "Processing value: " << *p << std::endl;
7
} else {
8
std::cout << "Processing null pointer." << std::endl;
9
}
10
}
11
12
int main() {
13
std::unique_ptr<int> ptr = std::make_unique<int>(100);
14
15
// 使用 get() 获取裸指针与旧 API 交互
16
process_raw_pointer(ptr.get());
17
18
// 也可以用来检查是否为空
19
if (ptr.get() != nullptr) {
20
std::cout << "ptr is not null (using get())." << std::endl;
21
}
22
23
return 0;
24
}
⚝ 注意事项 (Precautions):
▮▮▮▮⚝ 绝对不要通过 get() 返回的裸指针手动释放资源（例如，调用 delete 或 delete[]），除非您随后立即调用 release() 放弃 unique_ptr 的所有权。这样做会导致资源被重复释放 (double free)。
▮▮▮▮⚝ get() 返回的裸指针的生命周期与 unique_ptr 的生命周期绑定。当 unique_ptr 被销毁或 reset() 时，它管理的资源会被释放，此时通过 get() 获取的裸指针将成为野指针 (dangling pointer)。
4.1.2 release() 方法：放弃所有权
release() 方法放弃 unique_ptr 对其当前管理的资源的控制权，并返回该资源的原始指针。unique_ptr 在调用 release() 后将不再管理该资源，其内部指针变为 nullptr。
⚝ 目的 (Purpose):
▮▮▮▮⚝ 在特定场景下，需要将 unique_ptr 管理的资源所有权转移给其他机制或手动管理。
▮▮▮▮⚝ 与 reset() 结合使用，但通常直接使用 reset(new_ptr) 更安全简洁。
⚝ 用法 (Usage):
1
#include <memory>
2
#include <iostream>
3
4
int main() {
5
std::unique_ptr<int> ptr = std::make_unique<int>(200);
6
7
// ptr 现在管理着 int(200) 的内存
8
std::cout << "Before release, ptr manages: " << *ptr << std::endl;
9
10
// 放弃所有权，获取裸指针
11
int* raw_ptr = ptr.release();
12
13
// ptr 现在不再管理资源，内部指针为 nullptr
14
std::cout << "After release, ptr is null: " << (ptr == nullptr) << std::endl;
15
16
// 现在 raw_ptr 负责管理这块内存
17
if (raw_ptr) {
18
std::cout << "Manually managing raw_ptr: " << *raw_ptr << std::endl;
19
// ... 在这里对 raw_ptr 进行操作 ...
20
// **重要：必须手动释放这块内存**
21
delete raw_ptr;
22
std::cout << "Manually deleted raw_ptr." << std::endl;
23
}
24
25
return 0;
26
}
⚝ 注意事项 (Precautions):
▮▮▮▮⚝ 调用 release() 后，unique_ptr 不会释放资源。您必须自己负责释放 release() 返回的裸指针所指向的资源，否则会导致内存泄漏 (memory leak)。
▮▮▮▮⚝ 使用 release() 的场景相对较少。大多数所有权转移场景应优先考虑使用移动语义 (std::move) 或 reset()。
4.1.3 reset() 方法：释放并/或接管资源
reset() 方法有两个主要功能：
- 释放
unique_ptr当前管理的资源。 - （可选）接管一个新的原始指针所指向的资源。
⚝ 用法 (Usage):
▮▮▮▮ⓐ ptr.reset(): 释放当前管理的资源，并将 ptr 设置为 nullptr。
▮▮▮▮ⓑ ptr.reset(raw_ptr): 释放当前管理的资源，然后接管 raw_ptr 指向的资源。
⚝ 示例 (Examples):
1
#include <memory>
2
#include <iostream>
3
4
int main() {
5
std::unique_ptr<int> ptr = std::make_unique<int>(300);
6
std::cout << "Initial ptr value: " << *ptr << std::endl;
7
8
// 释放当前资源，ptr 变为空
9
ptr.reset();
10
std::cout << "After reset(), ptr is null: " << (ptr == nullptr) << std::endl;
11
12
// 接管一个新的资源
13
int* new_int = new int(400);
14
ptr.reset(new_int);
15
std::cout << "After reset(new_int), ptr manages: " << *ptr << std::endl;
16
17
// reset() 也支持传入 nullptr，效果同 reset()
18
ptr.reset(nullptr);
19
std::cout << "After reset(nullptr), ptr is null: " << (ptr == nullptr) << std::endl;
20
21
return 0; // ptr 销毁时会调用析构函数，但此时 ptr 为 nullptr，所以不会释放资源
22
}
⚝ 注意事项 (Precautions):
▮▮▮▮⚝ 如果 reset(raw_ptr) 中的 raw_ptr 就是 ptr.get() 当前返回的指针，行为是未定义的 (undefined behavior)。换句话说，不要 ptr.reset(ptr.get())。
▮▮▮▮⚝ reset(raw_ptr) 是异常安全的：如果在获取 raw_ptr 或释放旧资源时发生异常，unique_ptr 仍能保持有效状态。
4.2 定制删除器 (Custom Deleter)
默认情况下，std::unique_ptr<T> 使用 delete 来释放 T 类型的对象，而 std::unique_ptr<T[]> 使用 delete[] 来释放 T 类型的数组。然而，在实际开发中，我们可能需要管理非内存资源（如文件句柄、网络套接字、数据库连接等），或者需要使用特定的函数（如 free, fclose, CloseHandle 等）而不是 delete 来释放资源。这时，定制删除器就派上用场了。
定制删除器是 unique_ptr 模板的第二个参数，它是一个类型，这个类型的对象或函数会在 unique_ptr 析构时被调用，负责执行资源的释放操作。
⚝ 基本概念 (Basic Concept):
定制删除器是一个可调用对象 (Callable Object)，它可以是：
▮▮▮▮⚝ 函数指针 (function pointer)。
▮▮▮▮⚝ 函数对象 (functor)，即重载了 operator() 的类的对象。
▮▮▮▮⚝ Lambda 表达式 (Lambda expression)。
这个可调用对象接受一个参数，类型是 unique_ptr 所管理的资源的原始指针类型（或可隐式转换为该类型）。当 unique_ptr 需要释放资源时，它会调用这个定制删除器，并将内部的原始指针传递给它。
4.2.1 使用函数指针作为删除器
函数指针是最简单的定制删除器形式，适用于资源释放函数签名固定的情况。
⚝ 签名要求 (Signature Requirement):
函数指针指向的函数必须接受一个 unique_ptr 所管理类型的指针作为参数，并且没有返回值（void）。例如，对于 unique_ptr<int, void(*)(int*)>，删除器函数签名为 void(int*)。对于 unique_ptr<FILE, void(*)(FILE*)>，删除器函数签名为 void(FILE*)。
⚝ 示例：管理 FILE*
1
#include <memory>
2
#include <cstdio> // for FILE, fopen, fclose
3
#include <iostream>
4
5
// 定义一个用于关闭 FILE* 的函数
6
void file_closer(FILE* fp) {
7
if (fp) {
8
std::cout << "Closing file via custom deleter." << std::endl;
9
std::fclose(fp);
10
}
11
}
12
13
int main() {
14
// unique_ptr 的类型需要指定删除器类型
15
// unique_ptr<资源类型, 删除器类型>
16
using FilePtr = std::unique_ptr<FILE, void(*)(FILE*)>;
17
18
// 使用定制删除器创建 unique_ptr
19
// 第二个参数传入删除器函数的地址
20
FilePtr file = FilePtr(std::fopen("example.txt", "w"), file_closer);
21
22
if (file) {
23
std::fputs("Hello, unique_ptr!\n", file.get());
24
std::cout << "File written." << std::endl;
25
} else {
26
std::cerr << "Failed to open file." << std::endl;
27
}
28
29
// file 在离开作用域时会自动调用 file_closer(file.get())
30
std::cout << "Leaving scope, unique_ptr will close the file." << std::endl;
31
32
return 0;
33
}
注意，在 FilePtr 类型别名中，删除器类型是 void(*)(FILE*)，表示一个指向接受 FILE* 并返回 void 的函数的指针。创建 FilePtr 对象时，构造函数需要传入原始指针和删除器函数的地址 (file_closer)。
4.2.2 使用函数对象或 Lambda 表达式作为删除器
函数对象 (functor) 和 Lambda 表达式提供了更大的灵活性，特别是当删除器需要维护一些状态或其逻辑较为复杂时。
⚝ 示例：使用函数对象 (Functor) 管理资源
1
#include <memory>
2
#include <iostream>
3
4
// 定义一个函数对象作为删除器
5
struct MyDeleter {
6
void operator()(int* p) const {
7
if (p) {
8
std::cout << "Deleting int via MyDeleter." << std::endl;
9
delete p;
10
}
11
}
12
};
13
14
int main() {
15
// 使用函数对象类型作为删除器类型
16
std::unique_ptr<int, MyDeleter> ptr(new int(500));
17
18
std::cout << "ptr manages: " << *ptr << std::endl;
19
20
// ptr 在离开作用域时，会调用 MyDeleter()(*ptr.get())
21
std::cout << "Leaving scope, unique_ptr will delete the int." << std::endl;
22
23
return 0;
24
}
这里的删除器类型是 MyDeleter，创建 unique_ptr 对象时，构造函数会自动创建一个 MyDeleter 类型的对象并存储在 unique_ptr 内部（如果删除器是无状态的，通常会进行优化）。
⚝ 示例：使用 Lambda 表达式管理资源
Lambda 表达式是 C++11 引入的便利特性，对于简单的定制删除器尤其方便。
1
#include <memory>
2
#include <iostream>
3
#include <windows.h> // 假设管理 Windows HANDLE
4
5
int main() {
6
// 使用 Lambda 表达式作为删除器
7
// Lambda 表达式通常没有特定的命名类型，所以删除器类型可以使用 decltype() 获取
8
auto handle_deleter = [](HANDLE h) {
9
if (h != INVALID_HANDLE_VALUE && h != nullptr) {
10
std::cout << "Closing handle via lambda deleter." << std::endl;
11
CloseHandle(h);
12
}
13
};
14
15
// 获取一个示例 HANDLE (这里使用标准输出的句柄作为例子)
16
HANDLE hStdout = GetStdHandle(STD_OUTPUT_HANDLE);
17
18
// 使用 Lambda 表达式的类型作为删除器类型
19
// unique_ptr<资源类型, decltype(lambda_变量)>
20
std::unique_ptr<std::remove_pointer<HANDLE>::type, decltype(handle_deleter)> unique_handle(hStdout, handle_deleter);
21
// std::remove_pointer<HANDLE>::type 用于获取 HANDLE 的非指针类型，因为 unique_ptr 要求管理非指针类型 T
22
23
std::cout << "unique_handle manages a HANDLE." << std::endl;
24
25
// unique_handle 在离开作用域时，会自动调用 lambda 删除器
26
std::cout << "Leaving scope, unique_ptr will close the handle." << std::endl;
27
28
// 注意：这里的 GetStdHandle 返回的句柄不应该被关闭，这个例子仅用于演示定制删除器
29
// 在实际应用中，你会使用 CreateFile 等函数获取需要关闭的句柄
30
// 为了示例的健壮性，这里不执行实际的 CloseHandle 调用，或者管理一个通过 CreateFile 获得的临时句柄
31
// 为了演示，我们创建一个需要释放的资源
32
HANDLE temp_handle = CreateEvent(nullptr, TRUE, FALSE, nullptr); // 创建一个事件句柄
33
if (temp_handle != nullptr) {
34
std::unique_ptr<std::remove_pointer<HANDLE>::type, decltype(handle_deleter)> real_handle(temp_handle, handle_deleter);
35
std::cout << "Created and managing a real handle." << std::endl;
36
// real_handle 离开作用域时会调用 CloseHandle
37
}
38
39
40
return 0;
41
}
使用 Lambda 表达式时，由于其类型是编译器生成的匿名类型，通常需要使用 decltype 来获取其类型作为 unique_ptr 的模板参数。如果 Lambda 捕获了变量（即是有状态的），它就是一个有状态的函数对象。
4.2.3 删除器对 unique_ptr 类型和大小的影响
定制删除器是 unique_ptr 模板参数的一部分 (template< class T, class Deleter = std::default_delete<T> > class unique_ptr;)。这意味着：
⚝ 类型影响 (Type Impact):
带有不同删除器类型的 unique_ptr 被视为不同的类型。例如，unique_ptr<int, std::default_delete<int>> 和 unique_ptr<int, void(*)(int*)> 是两个不同的类型。它们之间不能直接相互赋值或转换，除非使用 std::move 进行移动，并且移动是允许的（例如，从一个 unique_ptr<T, D1> 移动到一个 unique_ptr<T, D2>，需要 D2 能够从 D1 构造或赋值）。
⚝ 大小影响 (Size Impact):
unique_ptr 的大小通常是存储一个原始指针的大小，但在包含定制删除器时可能会增加。
▮▮▮▮ⓐ 无状态删除器 (Stateless Deleter): 如果删除器是无状态的（如函数指针或不捕获任何变量的 Lambda 表达式/函数对象），编译器通常可以通过空基类优化 (Empty Base Optimization - EBO) 来避免增加 unique_ptr 的大小。在这种情况下，unique_ptr 的大小通常与原始指针的大小相同。
▮▮▮▮ⓑ 有状态删除器 (Stateful Deleter): 如果删除器是一个捕获了变量的 Lambda 表达式或一个包含成员变量的函数对象，它就是有状态的。这种删除器对象需要存储其状态，因此 unique_ptr 的大小将是原始指针的大小加上删除器对象的大小。
⚝ 示例：有状态删除器
1
#include <memory>
2
#include <iostream>
3
4
struct StatefulDeleter {
5
std::string log_message;
6
StatefulDeleter(const std::string& msg) : log_message(msg) {}
7
void operator()(int* p) const {
8
if (p) {
9
std::cout << log_message << *p << std::endl;
10
delete p;
11
}
12
}
13
};
14
15
int main() {
16
// 有状态删除器会增加 unique_ptr 的大小
17
std::unique_ptr<int, StatefulDeleter> ptr(new int(600), StatefulDeleter("Deleting value: "));
18
19
std::cout << "Size of raw pointer (int*): " << sizeof(int*) << std::endl;
20
std::cout << "Size of unique_ptr with stateful deleter: " << sizeof(ptr) << std::endl;
21
// 通常 size of ptr 会大于等于 size of int* + size of std::string
22
23
// ptr 离开作用域时会调用带状态的删除器
24
return 0;
25
}
在选择定制删除器时，如果对性能和内存布局有严格要求，并且删除器不需要状态，优先使用函数指针或无状态的 Lambda/函数对象是一个好的选择。
4.3 unique_ptr 对数组的支持 (unique_ptr)
动态分配数组（使用 new T[N]）必须使用 delete[] 来释放。如果错误地使用了 delete，会导致未定义行为 (undefined behavior)，通常表现为内存泄漏或程序崩溃。std::unique_ptr 提供了一个特化版本 std::unique_ptr<T[]>，专门用于管理动态分配的数组，并确保使用 delete[] 进行正确的释放。
⚝ 用法 (Usage):
使用 unique_ptr<T[]> 来代替裸指针 T* 管理数组。
1
#include <memory>
2
#include <iostream>
3
#include <cstddef> // for std::size_t
4
5
int main() {
6
const std::size_t size = 5;
7
8
// 使用 new[] 分配数组，用 unique_ptr<int[]> 管理
9
std::unique_ptr<int[]> arr_ptr(new int[size]);
10
11
// 在 C++14 及以后，优先使用 std::make_unique<T[]>(size)
12
// std::unique_ptr<int[]> arr_ptr = std::make_unique<int[]>(size);
13
14
15
// 使用 operator[] 访问数组元素
16
for (std::size_t i = 0; i < size; ++i) {
17
arr_ptr[i] = i * 10;
18
std::cout << "arr_ptr[" << i << "] = " << arr_ptr[i] << std::endl;
19
}
20
21
// unique_ptr<int[]> 离开作用域时，会自动调用 delete[] arr_ptr.get()
22
std::cout << "Leaving scope, unique_ptr will delete the array." << std::endl;
23
24
// 注意：unique_ptr<T[]> 没有 operator* 和 operator->，因为它们对数组没有明确意义。
25
// 它提供了 operator[]。
26
// get() 方法返回 T*。
27
// size() 方法 (如果需要) 需要自己实现或用其他方式跟踪。
28
29
return 0;
30
}
⚝ 关键特性 (Key Features):
▮▮▮▮⚝ 自动使用 delete[]: unique_ptr<T[]> 的默认删除器是 std::default_delete<T[]>，它确保在析构时调用 delete[]，从而避免了与数组相关的内存释放错误。
▮▮▮▮⚝ 提供 operator[]: 可以像裸指针一样使用方括号 ([]) 访问数组中的元素。
▮▮▮▮⚝ 不支持 operator* 和 operator->: 这两个运算符对于数组类型的指针没有普遍的意义，因此 unique_ptr<T[]> 不提供它们。
▮▮▮▮⚝ get() 返回 T*: 返回指向数组第一个元素的裸指针。
▮▮▮▮⚝ 推荐使用 std::make_unique<T[]> (C++14): 类似于 make_unique<T>，它是创建 unique_ptr<T[]> 的首选方式，提供异常安全和简洁性。
⚝ 错误示例 (Incorrect Example):
1
#include <memory>
2
#include <iostream>
3
4
int main() {
5
// 这是错误的！unique_ptr<int> 的默认删除器是 delete，而不是 delete[]
6
// 这将导致未定义行为！
7
// std::unique_ptr<int> bad_ptr(new int[5]); // 编译可能不报错，但运行时错误
8
9
// 正确的做法是使用 unique_ptr<int[]>
10
std::unique_ptr<int[]> good_ptr(new int[5]);
11
12
// ... 使用 good_ptr ...
13
14
return 0; // good_ptr 会正确调用 delete[]
15
}
始终为动态分配的数组使用 unique_ptr<T[]>。
4.4 其他成员函数：swap(), operator bool, operator*, operator->
除了前面讨论的资源管理方法，std::unique_ptr 还提供了一些其他的实用成员函数，用于交换所有权、检查状态以及访问底层对象。
4.4.1 swap()：交换所有权
swap() 方法用于高效地交换两个 unique_ptr 对象所管理资源的所有权。
⚝ 用法 (Usage):
1
#include <memory>
2
#include <iostream>
3
#include <utility> // For std::swap, although member swap is usually preferred
4
5
int main() {
6
std::unique_ptr<int> ptr1 = std::make_unique<int>(700);
7
std::unique_ptr<int> ptr2 = std::make_unique<int>(800);
8
9
std::cout << "Before swap:" << std::endl;
10
std::cout << "ptr1 manages: " << (ptr1 ? std::to_string(*ptr1) : "nothing") << std::endl;
11
std::cout << "ptr2 manages: " << (ptr2 ? std::to_string(*ptr2) : "nothing") << std::endl;
12
13
// 交换 ptr1 和 ptr2 管理的资源
14
ptr1.swap(ptr2);
15
// 或者使用非成员 std::swap(ptr1, ptr2);
16
17
std::cout << "After swap:" << std::endl;
18
std::cout << "ptr1 manages: " << (ptr1 ? std::to_string(*ptr1) : "nothing") << std::endl;
19
std::cout << "ptr2 manages: " << (ptr2 ? std::to_string(*ptr2) : "nothing") << std::endl;
20
21
return 0;
22
}
⚝ 优势 (Advantage):
swap() 操作通常只涉及内部指针的交换，是 O(1) 的操作，非常高效。它比先 release() 再 reset() 或通过移动赋值要更直接和清晰地表达交换意图。
4.4.2 operator bool：检查是否持有资源
unique_ptr 重载了布尔转换运算符 (operator bool)，允许您方便地检查 unique_ptr 是否持有资源（即其内部指针是否为 nullptr）。
⚝ 用法 (Usage):
可以直接在条件语句中使用 unique_ptr 对象。
1
#include <memory>
2
#include <iostream>
3
4
int main() {
5
std::unique_ptr<int> ptr1 = std::make_unique<int>(900);
6
std::unique_ptr<int> ptr2; // 默认构造为 nullptr
7
8
if (ptr1) { // 等价于 if (ptr1.get() != nullptr)
9
std::cout << "ptr1 holds a resource." << std::endl;
10
} else {
11
std::cout << "ptr1 does not hold a resource." << std::endl;
12
}
13
14
if (ptr2) { // 等价于 if (ptr2.get() != nullptr)
15
std::cout << "ptr2 holds a resource." << std::endl;
16
} else {
17
std::cout << "ptr2 does not hold a resource." << std::endl;
18
}
19
20
return 0;
21
}
⚝ 推荐 (Recommendation):
在检查 unique_ptr 是否为空时，优先使用 operator bool (即 if (ptr))，这比使用 ptr.get() != nullptr 更简洁和符合习惯。
4.4.3 operator* 和 operator->：访问底层对象
unique_ptr 重载了解引用运算符 (operator*) 和箭头运算符 (operator->)，允许您直接像使用裸指针一样访问其所管理的对象。
⚝ 用法 (Usage):
1
#include <memory>
2
#include <iostream>
3
#include <string>
4
5
struct MyObject {
6
int value;
7
std::string name;
8
void greet() const {
9
std::cout << "Hello from " << name << " with value " << value << "!" << std::endl;
10
}
11
};
12
13
int main() {
14
std::unique_ptr<MyObject> obj_ptr = std::make_unique<MyObject>();
15
16
// 访问成员变量
17
obj_ptr->value = 1000;
18
obj_ptr->name = "Unique Object";
19
20
// 调用成员函数
21
obj_ptr->greet();
22
23
// 解引用获取对象本身
24
MyObject& obj_ref = *obj_ptr;
25
std::cout << "Accessed via dereference: value = " << obj_ref.value << std::endl;
26
27
return 0; // obj_ptr 离开作用域时会删除 MyObject 对象
28
}
⚝ 注意事项 (Precautions):
▮▮▮▮⚝ 在使用 operator* 或 operator-> 之前，必须确保 unique_ptr 不是空的（即它正在管理一个有效的对象）。如果对一个空的 unique_ptr 进行解引用或使用箭头运算符，会导致未定义行为，通常是程序崩溃。可以使用 if (ptr) 先进行检查。
▮▮▮▮⚝ 如 4.3 节所述，unique_ptr<T[]> 不提供这两个运算符。
掌握 unique_ptr 的这些成员函数，您就可以在需要时与它管理的资源进行精细交互，实现更复杂的资源管理逻辑，同时依然享受 unique_ptr 提供的自动资源释放和所有权管理带来的安全性。
5. unique_ptr 与其他指针的比较与选择
本章将 unique_ptr 与裸指针、C++11 前的智能指针以及其他现代 C++ 智能指针进行对比，帮助读者理解它们各自的适用场景，从而在实际开发中做出明智的选择。理解 unique_ptr 在 C++ 智能指针家族中的定位，是深入掌握其使用价值的关键。
5.1 unique_ptr vs 裸指针 (Raw Pointer)
在 C++11 引入 unique_ptr 之前，裸指针 (raw pointer) 是管理动态分配资源（主要是内存）的主要方式。然而，使用裸指针进行手动资源管理充满了陷阱，极易引入错误，导致程序不稳定甚至崩溃。unique_ptr 的出现正是为了解决这些问题，提供了一种更安全、更自动化的资源管理机制。
让我们对比使用 unique_ptr 和裸指针在资源管理、安全性、代码清晰度等方面的区别。
① 资源管理：手动 vs 自动
裸指针本身不包含任何资源管理信息。它只是一个地址。资源的生命周期完全由程序员负责跟踪和管理，包括何时分配、何时释放。
⚝ 裸指针的问题：
▮▮▮▮⚝ 内存泄漏 (Memory Leak): 如果在资源使用完毕后忘记调用 delete 或 delete[]，或者在释放前提前退出作用域（例如由于异常发生），资源将无法被释放，导致内存泄漏。长时间运行的程序中，这会耗尽系统资源。
▮▮▮▮⚝ 重复释放 (Double Free): 对同一块内存区域调用两次 delete 会导致未定义行为 (undefined behavior)，程序可能崩溃。
▮▮▮▮⚝ 野指针 (Dangling Pointer): 在资源被释放后，指向该资源的裸指针并没有被置为 nullptr。后续如果通过这个野指针访问内存，会导致未定义行为。
▮▮▮▮⚝ 忘记 delete vs delete[]: 对通过 new 分配的对象数组使用 delete 而非 delete[]，或反之，也会导致未定义行为。
1
// 裸指针示例
2
void process_data() {
3
int* data = new int[10];
4
// ... 使用 data ...
5
6
// 如果此处抛出异常，或者忘记 delete[]
7
// delete[] data; // 资源泄漏风险
8
9
// 即使释放了，如果后续不小心再次使用 data
10
// delete[] data; // 重复释放风险
11
// data = nullptr; // 避免野指针
12
} // 离开作用域，如果没 delete[]，内存泄漏
unique_ptr 利用 RAII（资源获取即初始化 Resource Acquisition Is Initialization）原则，将资源的生命周期绑定到 unique_ptr 对象的生命周期上。当 unique_ptr 对象在其作用域结束时被销毁，它会自动调用其删除器（默认为 delete 或 delete[]）来释放所管理的资源。
⚝ unique_ptr 的优势：
▮▮▮▮⚝ 自动释放资源： 只要 unique_ptr 对象本身正确地管理，它在其生命周期结束时自动释放资源，极大地减少了内存泄漏的风险。
▮▮▮▮⚝ 防止重复释放： unique_ptr 具有独占所有权，同一时间只有一个 unique_ptr 对象管理特定资源。移动所有权后，原 unique_ptr 变为空，不会发生重复释放。
▮▮▮▮⚝ 避免野指针： 当 unique_ptr 释放资源后，它内部的指针会自动变为空指针（通过 reset() 或析构）。通过移动所有权，原 unique_ptr 也会变空。这有助于避免野指针问题。
▮▮▮▮⚝ 正确释放数组： std::unique_ptr<T[]> 特化版本会自动使用 delete[] 释放数组，无需手动区分。
1
// unique_ptr 示例
2
void process_data_safe() {
3
// 使用 std::make_unique 创建
4
auto data_ptr = std::make_unique<int[]>(10); // C++14 及以后
5
// 或者使用 new (不推荐)
6
// std::unique_ptr<int[]> data_ptr(new int[10]); // C++11
7
8
// ... 使用 data_ptr ...
9
10
// 无论如何退出作用域 (正常返回或异常)，data_ptr 都会自动析构
11
// 并在析构时调用 delete[] 释放内存。无需手动释放。
12
13
} // 离开作用域，data_ptr 自动释放内存
② 安全性与异常安全 (Exception Safety)
裸指针在遇到异常时非常脆弱。如果在分配资源后、释放资源前发生异常，资源将无法被释放，导致内存泄漏。
1
void leaky_function() {
2
int* resource = new int; // 分配资源
3
4
// 可能抛出异常的操作
5
do_something_that_might_throw();
6
7
delete resource; // 如果上面抛异常，这行不会执行
8
} // 内存泄漏
unique_ptr 则天然地提供了强大的异常安全保证。由于资源管理绑定在对象的生命周期上，无论程序流程如何（正常退出或因异常栈展开），unique_ptr 的析构函数都会被调用，从而保证资源得到及时释放。
1
void safe_function() {
2
auto resource_ptr = std::make_unique<int>(); // 资源由 unique_ptr 管理
3
4
// 可能抛出异常的操作
5
do_something_that_might_throw();
6
7
// 无论 do_something_that_might_throw() 是否抛异常，
8
// resource_ptr 在离开作用域时都会被正确析构并释放资源。
9
} // 异常安全，无内存泄漏
③ 所有权语义 (Ownership Semantics)
裸指针没有明确的所有权概念。多个裸指针可以指向同一块内存，但哪个指针负责释放则是不确定的，这容易导致重复释放或遗忘释放。
unique_ptr 明确表达了独占所有权 (exclusive ownership)。一个 unique_ptr 对象是其所管理资源的唯一所有者。这种明确的所有权模型使得代码的意图更加清晰，也便于进行资源的转移（通过移动语义）。
④ 代码清晰度与维护性
使用裸指针的代码往往充斥着 new 和 delete 调用，且需要仔细跟踪资源的生命周期。这增加了代码的复杂性，降低了可读性和可维护性。
使用 unique_ptr 的代码更简洁，资源管理逻辑被封装在 unique_ptr 内部。程序员可以将注意力更多地放在业务逻辑上，而无需分散精力去手动管理资源。这使得代码更易于理解、编写和维护。
总结 unique_ptr 相较于裸指针的优势：
⚝ 安全性更高： 显著降低内存泄漏、重复释放和野指针的风险。
⚝ 异常安全： 自动保证资源在异常发生时也能被正确释放。
⚝ 代码更简洁： 封装了资源管理细节，减少了手动管理代码。
⚝ 意图更清晰： 独占所有权语义明确表达了资源的归属。
何时仍然可能使用裸指针？
尽管 unique_ptr 有诸多优势，但在某些特定场景下，裸指针仍然有用武之地：
⚝ 指向非堆分配的内存，例如栈上对象或全局/静态对象。
⚝ 指向由 C 风格 API 管理的资源，这些 API 提供分配和释放函数（尽管通常更推荐使用定制删除器）。
⚝ 在性能极度敏感的内部循环中，且能确保资源管理逻辑的正确性（但这种情况非常罕见，unique_ptr 的开销通常可以忽略）。
⚝ 作为非所有权 (non-owning) 指针，仅用于观察或访问对象，而不负责其生命周期（尽管对于这种情况，更推荐使用引用或 observer_ptr (非标准) 来明确意图）。
在绝大多数需要动态分配资源的场景下，优先选择 unique_ptr 或其他智能指针是现代 C++ 的最佳实践。
5.2 unique_ptr vs auto_ptr (已废弃)
在 C++11 之前，标准库提供了一个智能指针 std::auto_ptr (定义在 <memory>)。它的设计初衷也是为了实现资源的自动管理和独占所有权。然而，auto_ptr 的设计存在一个致命的缺陷，导致它在很多情况下表现出非直观甚至危险的行为，最终在 C++11 中被废弃 (deprecated)，并在 C++17 中被彻底移除 (removed)。unique_ptr 可以视为对 auto_ptr 概念的继承和修正。
① auto_ptr 的所有权语义缺陷
auto_ptr 试图实现独占所有权，但它通过拷贝构造和拷贝赋值来实现所有权转移，而非拷贝。这意味着当一个 auto_ptr 被拷贝时，它会“偷走”源 auto_ptr 所管理资源的所有权，并把源 auto_ptr 置为空。
1
// auto_ptr 示例 (C++11 之前或使用兼容模式)
2
#include <memory>
3
#include <iostream>
4
5
void auto_ptr_demo() {
6
std::auto_ptr<int> ptr1(new int(10));
7
std::cout << "ptr1 value before copy: " << *ptr1 << std::endl; // OK
8
9
std::auto_ptr<int> ptr2 = ptr1; // **危险！** ptr1 的所有权被转移给 ptr2
10
11
// 此时，ptr1 内部的指针已经变空了！
12
// 访问 ptr1 将导致未定义行为 (通常是崩溃)
13
// std::cout << "ptr1 value after copy: " << *ptr1 << std::endl; // **运行时错误！**
14
15
std::cout << "ptr2 value after copy: " << *ptr2 << std::endl; // OK
16
} // ptr2 销毁时释放内存，ptr1 是空的，不会重复释放
这种行为在程序员期望拷贝行为时（即两个指针都有效且指向同一资源）却发生了所有权转移，这违背了直观的认知，并且在作为函数参数按值传递时尤其危险，因为函数返回后原始的 auto_ptr 参数会变空，导致后续使用出错。
② unique_ptr 的改进：移动语义
unique_ptr 吸取了 auto_ptr 的教训，通过禁用拷贝构造和拷贝赋值，明确禁止了传统的拷贝行为。它只允许通过移动构造和移动赋值来转移所有权。这得益于 C++11 引入的移动语义 (move semantics)。
1
// unique_ptr 示例 (现代 C++)
2
#include <memory>
3
#include <iostream>
4
#include <utility> // 对于 std::move
5
6
void unique_ptr_demo() {
7
std::unique_ptr<int> ptr1(new int(10)); // 原始 unique_ptr
8
std::cout << "ptr1 value before move: " << *ptr1 << std::endl; // OK
9
10
// std::unique_ptr<int> ptr2 = ptr1; // **编译错误！** unique_ptr 不可拷贝
11
12
// 必须显式使用 std::move 来转移所有权
13
std::unique_ptr<int> ptr2 = std::move(ptr1);
14
15
// 此时，ptr1 内部的指针已经变空了。
16
// 尝试解引用 ptr1 会导致运行时错误 (通常是崩溃)。
17
// std::cout << "ptr1 value after move: " << *ptr1 << std::endl; // **运行时错误！**
18
19
std::cout << "ptr2 value after move: " << *ptr2 << std::endl; // OK
20
} // ptr2 销毁时释放内存，ptr1 是空的
使用 std::move 明确表达了程序员想要转移所有权的意图，使得代码的行为更加可预测和安全。这种显式性是 unique_ptr 相较于 auto_ptr 的重要改进。
③ 编译期检查 vs 运行时错误
auto_ptr 的问题在于其“窃取”行为是在运行时发生的，可能导致难以调试的运行时错误。而 unique_ptr 的不可拷贝性是在编译期强制执行的。任何试图拷贝 unique_ptr 的操作都会导致编译错误，从而在早期发现并修正问题。
总结 unique_ptr 相较于 auto_ptr 的优势：
⚝ 正确的所有权转移： 利用 C++11 的移动语义，实现清晰、安全的独占所有权转移。
⚝ 编译期安全性： 不可拷贝性在编译时捕获潜在的错误，而非留待运行时。
⚝ 意图明确： 使用 std::move 显式表示所有权转移。
⚝ 数组支持： std::unique_ptr<T[]> 正确处理动态数组，而 auto_ptr<T[]> 会导致未定义行为。
由于 auto_ptr 的设计缺陷以及 unique_ptr 作为其安全替代品的出现，现在应完全避免使用 std::auto_ptr，转而使用 std::unique_ptr。
5.3 unique_ptr vs shared_ptr
unique_ptr 和 shared_ptr 是现代 C++ 中最常用的两种智能指针，它们都提供自动资源管理和异常安全。然而，它们的核心区别在于所有权模型：unique_ptr 实现独占所有权，而 shared_ptr 实现共享所有权 (shared ownership)。理解这一区别及其带来的影响是选择正确智能指针的关键。
① 所有权模型：独占 vs 共享
⚝ unique_ptr：独占所有权。 同一时间只有一个 unique_ptr 对象拥有资源的控制权。所有权可以通过 std::move 转移，但不能拷贝。这适用于资源具有单一明确所有者的情况。
⚝ shared_ptr：共享所有权。 多个 shared_ptr 对象可以共同拥有同一资源的控制权。shared_ptr 内部使用引用计数 (reference count) 来追踪有多少个 shared_ptr 对象指向该资源。当最后一个 shared_ptr 对象被销毁时，资源才会被释放。这适用于资源需要被多个部分共享，且没有单一明确所有者的情况。
② 实现机制：无开销 ( लगभग Zero-overhead) vs 引用计数 (Reference Counting)
⚝ unique_ptr： 实现非常轻量。它通常只包含一个指向资源的裸指针（或者在有定制删除器时，可能包含删除器对象）。unique_ptr 的主要开销在其构造和析构时，这与裸指针的 new/delete 开销相当。在运行时，访问 unique_ptr 管理的资源（通过 operator* 或 operator->）几乎与裸指针无异，通常是零开销抽象 (zero-overhead abstraction) 的一个例子。移动 unique_ptr 仅仅是指针的浅拷贝，开销很小。
⚝ shared_ptr： 实现相对复杂。它包含两个指针：一个指向管理的资源，一个指向控制块 (control block)。控制块通常包含：
▮▮▮▮⚝ 强引用计数 (strong reference count)：记录有多少个 shared_ptr 指向资源。
▮▮▮▮⚝ 弱引用计数 (weak reference count)：记录有多少个 weak_ptr 指向资源。
▮▮▮▮⚝ 定制删除器和分配器的副本（如果指定了）。
每次拷贝或赋值 shared_ptr 都会修改控制块中的引用计数（原子操作，以保证线程安全）。资源的释放发生在强引用计数降为零时。创建 shared_ptr、拷贝、赋值和销毁 shared_ptr 都会涉及引用计数的增减，这带来了额外的运行时开销，尤其是在多线程环境下，引用计数操作需要使用原子指令。
③ 性能开销
由于不需要维护引用计数，unique_ptr 在性能上通常优于 shared_ptr。
⚝ unique_ptr：
▮▮▮▮⚝ 构造/析构开销 ≈ 裸指针的 new/delete。
▮▮▮▮⚝ 访问资源开销 ≈ 裸指针。
▮▮▮▮⚝ 移动开销极小。
▮▮▮▮⚝ 内存占用：通常是一个指针大小（有时加上定制删除器的大小）。
⚝ shared_ptr：
▮▮▮▮⚝ 构造/析构开销 > unique_ptr，涉及引用计数操作和控制块的管理。
▮▮▮▮⚝ 访问资源开销 ≈ 裸指针（通过内部指针间接访问）。
▮▮▮▮⚝ 拷贝/赋值开销 > unique_ptr，涉及引用计数原子操作。
▮▮▮▮⚝ 内存占用：通常是两个指针大小（一个指向资源，一个指向控制块）。
在性能是关键考虑因素的场景下，如果资源的所有权是独占的，应优先选择 unique_ptr。
④ 线程安全 (Thread Safety)
智能指针的线程安全是一个容易混淆的概念。
⚝ unique_ptr 的线程安全： unique_ptr 对象本身不提供多线程的并发访问安全。如果多个线程同时访问同一个 unique_ptr 对象（例如，一个线程读取，一个线程写入或移动），需要外部同步机制（如互斥锁 Mutex）。但是，unique_ptr 的所有权可以在线程之间安全地转移，因为转移后原 unique_ptr 变为空，不会与其他线程继续访问。
⚝ shared_ptr 的线程安全： shared_ptr 的控制块（包括引用计数）的增减操作是原子操作，是线程安全的。这意味着多个线程可以安全地拷贝、赋值、析构指向同一个资源的 shared_ptr 对象，引用计数会正确地更新。但是，shared_ptr 管理的资源对象本身不保证线程安全。如果多个线程通过不同的 shared_ptr 对象同时访问同一个资源对象，并且这些访问是非 const 的，仍然需要外部同步机制来保护资源。
简而言之，对于 shared_ptr：
⚝ 多个线程操作不同的 shared_ptr 对象（即使它们指向同一资源）：安全（引用计数操作是原子的）。
⚝ 多个线程通过 shared_ptr 操作（读/写）同一个资源对象：不安全，除非资源本身或访问被同步保护。
⑤ 适用场景
根据所有权模型和性能特性，两者有各自的最佳适用场景：
⚝ 选择 unique_ptr 的场景：
▮▮▮▮⚝ 资源具有清晰、单一的所有者。
▮▮▮▮⚝ 工厂函数返回新创建的对象，并将所有权移交给调用者。
▮▮▮▮⚝ 类成员变量管理动态分配的子对象或资源，且该资源生命周期与类对象绑定。
▮▮▮▮⚝ 存储在标准容器中，代表容器独占拥有的元素。
▮▮▮▮⚝ 需要管理文件句柄、网络连接等非内存资源，且这些资源也是独占的。
▮▮▮▮⚝ 性能要求高，且符合独占所有权模型。
⚝ 选择 shared_ptr 的场景：
▮▮▮▮⚝ 资源需要被多个不同的部分共享，且没有单一的、负责销毁所有者。
▮▮▮▮⚝ 对象生命周期不确定，取决于有多少部分仍在使用它（如缓存对象、GUI 控件等）。
▮▮▮▮⚝ 需要在多个回调函数、异步操作或不同线程之间共享资源。
▮▮▮▮⚝ 需要构建复杂的数据结构，其中节点可以被多个父节点引用（但要注意循环引用问题，可能需要 weak_ptr 辅助）。
何时不应使用 shared_ptr？
⚝ 资源有明确的独占所有者时，使用 unique_ptr 更高效且能更好地表达意图。
⚝ 担心引用计数开销时。
⚝ 需要管理数组时，shared_ptr<T[]> 在 C++17 才正式支持，之前使用可能导致问题（虽然技术上可行但不够直观），unique_ptr
示例对比：
假设有一个 Widget 类需要动态创建。
1
class Widget {
2
public:
3
Widget() { std::cout << "Widget constructed" << std::endl; }
4
~Widget() { std::cout << "Widget destroyed" << std::endl; }
5
void do_something() { std::cout << "Widget doing something" << std::endl; }
6
};
7
8
// 场景 1: 创建一个 Widget，其生命周期与函数作用域绑定
9
void create_scoped_widget() {
10
// 使用 unique_ptr
11
auto my_widget = std::make_unique<Widget>();
12
my_widget->do_something();
13
// 函数结束，my_widget 销毁，Widget 被释放。清晰、高效。
14
15
// 使用 shared_ptr
16
// auto my_widget = std::make_shared<Widget>();
17
// my_widget->do_something();
18
// 函数结束，my_widget 销毁。引用计数从 1 降到 0，Widget 被释放。
19
// 虽然结果一样，但在独占场景下 shared_ptr 引入了不必要的引用计数开销。
20
}
21
22
// 场景 2: 工厂函数创建 Widget 并转移所有权
23
std::unique_ptr<Widget> create_widget_factory() {
24
return std::make_unique<Widget>(); // 返回 unique_ptr，所有权转移
25
}
26
27
void use_factory() {
28
auto widget_ptr = create_widget_factory(); // 接收转移的所有权
29
widget_ptr->do_something();
30
} // widget_ptr 销毁，Widget 被释放。
31
32
// 如果工厂函数返回 shared_ptr
33
// std::shared_ptr<Widget> create_widget_factory_shared() {
34
// return std::make_shared<Widget>(); // 返回 shared_ptr
35
// }
36
// void use_factory_shared() {
37
// auto widget_ptr = create_widget_factory_shared();
38
// widget_ptr->do_something();
39
// } // widget_ptr 销毁，引用计数从 1 降到 0。
40
// 这也是一种有效方式，但在独占场景下 unique_ptr 表达意图更明确，且性能更好。
41
42
// 场景 3: 多个部分共享同一个 Widget
43
// std::shared_ptr 示例
44
std::shared_ptr<Widget> shared_widget;
45
46
void consumer1() {
47
if (shared_widget) { // 检查 shared_ptr 是否有效
48
shared_widget->do_something();
49
}
50
}
51
52
void consumer2() {
53
if (shared_widget) {
54
shared_widget->do_something();
55
}
56
}
57
58
void setup_shared_widget() {
59
shared_widget = std::make_shared<Widget>(); // 创建共享对象
60
// 多个 consumer 可以访问 shared_widget
61
consumer1();
62
consumer2();
63
} // setup_shared_widget 结束，shared_widget 引用计数减 1。
64
// Widget 的生命周期由所有 shared_ptr 共同控制。
65
66
// unique_ptr 不适合这种共享场景，因为所有权是独占的。
67
// 你无法在不转移所有权的情况下让 consumer1 和 consumer2 同时拥有并使用同一个 unique_ptr。
总的来说，unique_ptr 是默认选择，因为它性能更高，且在资源有单一所有者时能准确表达意图。只有当确实需要多处共享同一个资源时，才考虑使用 shared_ptr。
5.4 何时选择 unique_ptr？何时选择 shared_ptr？
选择哪种智能指针主要取决于资源的所有权语义和程序的具体需求。遵循以下原则通常能做出正确的选择：
① 首选 unique_ptr：
在大多数情况下，资源都倾向于有一个清晰的、独占的所有者。当一个对象或函数负责创建并管理某个资源的生命周期，且不打算与其他部分共享该资源的所有权时，unique_ptr 是最合适的选择。
选择 unique_ptr 的判断依据：
⚝ 资源只在一个地方被创建和销毁。
⚝ 资源的生命周期与某个特定的作用域（函数、类对象）紧密绑定。
⚝ 你需要将资源的所有权明确地从一处转移到另一处（例如从工厂函数返回、在容器中移动元素）。
⚝ 性能是一个重要考虑因素，并且独占所有权满足需求。
⚝ 需要管理动态分配的数组（std::unique_ptr<T[]>）。
⚝ 需要使用定制删除器来管理非内存资源（文件句柄、锁等），这些资源通常也是独占的。
unique_ptr 提供了“零开销”的资源管理抽象，其运行时开销与裸指针接近，且能有效防止资源泄漏和重复释放。它应该是你在现代 C++ 中管理动态资源时的首选工具，除非有明确理由需要共享所有权。
② 在需要共享所有权时使用 shared_ptr：
当资源需要被多个部分同时访问和管理，且没有一个单一的、负责销毁的实体时，shared_ptr 是必要的。
选择 shared_ptr 的判断依据：
⚝ 资源的生命周期不绑定于任何单一的作用域或对象，而是取决于有多少地方正在使用它。
⚝ 你需要多个不同的智能指针对象指向并共同管理同一个资源。
⚝ 资源需要在不同线程、回调函数或异步操作之间传递和共享。
⚝ 构建图形、树或其他包含共享节点的复杂数据结构（注意：可能需要 weak_ptr 打破循环引用）。
shared_ptr 引入了引用计数机制，带来了额外的性能开销和内存占用。只有当独占所有权模型无法满足需求时，才应该使用 shared_ptr。
③ 避免不必要的 shared_ptr：
不要仅仅因为它是“智能指针”就无脑使用 shared_ptr。如果在只需要独占所有权的场景下使用了 shared_ptr，虽然功能上可能正确，但会引入不必要的引用计数开销和内存开销，并且模糊了代码的意图。
④ 作为函数参数的传递：
根据需要选择传递智能指针的方式：
⚝ 传递 const unique_ptr&： 如果函数只需要访问资源，但不获取所有权，也不修改 unique_ptr 本身。
⚝ 通过值传递 unique_ptr (移动)： 如果函数需要获得资源的所有权。
⚝ 传递 const shared_ptr& 或 shared_ptr&： 如果函数需要共享资源的访问权，但不必增加引用计数（const&）或可能修改 shared_ptr 对象本身（&，较少见）。
⚝ 通过值传递 shared_ptr： 如果函数需要获得资源的一个共享所有权副本，从而延长资源的生命周期。
⚝ 传递裸指针或引用 (通过 get())： 当需要与接受裸指针或引用的旧 API 交互时。但要确保智能指针的生命周期覆盖裸指针/引用的使用范围。
总之，选择 unique_ptr 还是 shared_ptr 是现代 C++ 设计中的一个重要决策。理解它们各自的所有权模型和实现机制是做出正确选择的基础。“优先使用 unique_ptr，仅在需要共享所有权时使用 shared_ptr”是一个很好的指导原则。
5.5 简述 weak_ptr 与智能指针家族
weak_ptr（弱指针）是 shared_ptr 家族的一部分，定义在 <memory> 头文件中。它不能独立存在，必须与 shared_ptr 结合使用。weak_ptr 的主要目的是解决 shared_ptr 可能导致的循环引用 (circular reference) 问题。
① shared_ptr 循环引用问题
当两个或多个对象使用 shared_ptr 相互引用时，可能会形成一个引用循环。即使外部已经没有 shared_ptr 指向这些对象，它们的引用计数也不会降到零，因为它们内部的 shared_ptr 互相维持着引用计数。这会导致资源无法被释放，造成内存泄漏。
1
#include <memory>
2
#include <iostream>
3
4
class B; // 前向声明
5
6
class A {
7
public:
8
std::shared_ptr<B> b_ptr;
9
A() { std::cout << "A constructed" << std::endl; }
10
~A() { std::cout << "A destroyed" << std::endl; }
11
};
12
13
class B {
14
public:
15
std::shared_ptr<A> a_ptr;
16
B() { std::cout << "B constructed" << std::endl; }
17
~B() { std::cout << "B destroyed" << std::endl; }
18
};
19
20
void shared_ptr_cyclic_demo() {
21
std::cout << "Entering shared_ptr_cyclic_demo" << std::endl;
22
std::shared_ptr<A> sp_a = std::make_shared<A>();
23
std::shared_ptr<B> sp_b = std::make_shared<B>();
24
25
sp_a->b_ptr = sp_b; // A 持有 B 的 shared_ptr
26
sp_b->a_ptr = sp_a; // B 持有 A 的 shared_ptr
27
28
// 此时：
29
// sp_a 的引用计数为 2 (sp_a 自身 + sp_b->a_ptr)
30
// sp_b 的引用计数为 2 (sp_b 自身 + sp_a->b_ptr)
31
32
std::cout << "Leaving shared_ptr_cyclic_demo" << std::endl;
33
} // sp_a 和 sp_b 在这里被销毁，它们的引用计数都减 1。
34
// sp_a 的引用计数变为 1 (sp_b->a_ptr 仍然持有)
35
// sp_b 的引用计数变为 1 (sp_a->b_ptr 仍然持有)
36
// 引用计数都未能降到 0，A 和 B 对象都不会被销毁 -> 内存泄漏！
37
38
// int main() {
39
// shared_ptr_cyclic_demo();
40
// // 程序结束，A 和 B 的析构函数没有被调用
41
// return 0;
42
// }
② weak_ptr 的作用：观察者
weak_ptr 是一种“弱引用”或“观察者”指针。它指向由 shared_ptr 管理的资源，但不增加资源的引用计数。因此，weak_ptr 不会影响资源的生命周期。它提供了一种访问资源的方式，同时允许资源在所有强引用（shared_ptr）消失时被释放。
weak_ptr 的特点：
⚝ 不增加引用计数： weak_ptr 的存在不会阻止 shared_ptr 管理的资源被释放。
⚝ 没有直接访问： weak_ptr 不能直接通过 operator* 或 operator-> 访问资源。为了访问资源，必须先通过 lock() 方法将其升级 (promote) 为一个 shared_ptr。
⚝ lock() 方法： weak_ptr::lock() 返回一个 shared_ptr。如果资源仍然存在（即至少还有一个 shared_ptr 指向它），lock() 返回一个有效的 shared_ptr；否则，返回一个空的 shared_ptr。这是检查资源是否仍然有效并安全访问它的标准方式。
③ 使用 weak_ptr 解决循环引用
通过将循环中的一方（通常是“父”指向“子”的强引用，而“子”指向“父”的弱引用）改为 weak_ptr，可以打破引用循环。
1
#include <memory>
2
#include <iostream>
3
4
class Parent; // 前向声明
5
6
class Child {
7
public:
8
// Child 持有 Parent 的弱引用
9
std::weak_ptr<Parent> parent_ptr;
10
Child() { std::cout << "Child constructed" << std::endl; }
11
~Child() { std::cout << "Child destroyed" << std::endl; }
12
};
13
14
class Parent {
15
public:
16
// Parent 持有 Child 的强引用
17
std::shared_ptr<Child> child_ptr;
18
Parent() { std::cout << "Parent constructed" << std::endl; }
19
~Parent() { std::cout << "Parent destroyed" << std::endl; }
20
};
21
22
void weak_ptr_cyclic_demo() {
23
std::cout << "Entering weak_ptr_cyclic_demo" << std::endl;
24
std::shared_ptr<Parent> sp_parent = std::make_shared<Parent>();
25
std::shared_ptr<Child> sp_child = std::make_shared<Child>();
26
27
sp_parent->child_ptr = sp_child; // Parent 强引用 Child
28
sp_child->parent_ptr = sp_parent; // Child 弱引用 Parent
29
30
// 此时：
31
// sp_parent 的强引用计数为 1 (sp_parent 自身)
32
// sp_child 的强引用计数为 1 (sp_child 自身 + sp_parent->child_ptr)
33
// Parent 的弱引用计数为 1 (sp_child->parent_ptr)
34
35
std::cout << "Leaving weak_ptr_cyclic_demo" << std::endl;
36
} // sp_parent 和 sp_child 在这里被销毁，它们的强引用计数都减 1。
37
// sp_parent 的强引用计数变为 0。Parent 对象被销毁。
38
// Parent 析构时，其成员 child_ptr 被销毁，sp_child 的强引用计数从 1 减到 0。Child 对象被销毁。
39
// 无内存泄漏！
40
41
// int main() {
42
// weak_ptr_cyclic_demo();
43
// // Parent 和 Child 的析构函数都会被调用
44
// return 0;
45
// }
在这个例子中，sp_child 持有 sp_parent 的 weak_ptr，这不会阻止 sp_parent 的引用计数降到零。当 weak_ptr_cyclic_demo 函数结束，sp_parent 和 sp_child 智能指针对象被销毁时，sp_parent 的强引用计数首先降到零，Parent 对象被析构。在 Parent 析构过程中，其成员 child_ptr 被销毁，导致 sp_child 的强引用计数也降到零，Child 对象随之被析构。所有对象都被正确释放，避免了内存泄漏。
④ weak_ptr 的其他用途
除了解决循环引用，weak_ptr 还可以用于实现观察者模式或缓存失效机制，即允许某些对象观察其他对象的生命周期，但又不影响被观察对象的生存。通过 lock() 方法，观察者可以安全地获取资源的临时访问权限，并在资源已失效时得知。
⑤ 智能指针家族总结
⚝ unique_ptr： 独占所有权，轻量高效，默认首选。
⚝ shared_ptr： 共享所有权，基于引用计数，适用于多处共享资源的场景。
⚝ weak_ptr： 弱引用，不拥有资源，用于观察 shared_ptr 管理的资源，解决循环引用。
它们共同构成了现代 C++ 强大的智能指针家族，极大地提高了资源管理的安全性、健壮性和代码清晰度。
6. unique_ptr 的最佳实践与设计模式
在本章中，我们将探讨在实际 C++ 编程中如何有效地使用 std::unique_ptr。掌握一些最佳实践和常见的设计模式应用，能够帮助我们写出更安全、更清晰、更易于维护的现代 C++ 代码。我们将看到 unique_ptr 如何自然地融入到异常处理、对象创建和模块化设计中，并学习如何避免一些常见的陷阱。
6.1 编写异常安全的代码
异常安全 (exception safety) 是现代 C++ 编程中一个重要的考虑点。当程序执行过程中发生异常时，我们需要确保所有已获得的资源能够被正确释放，避免资源泄露。手动使用裸指针 (raw pointer) 和 new/delete 进行内存管理时，在出现异常的情况下极易发生内存泄露。
让我们来看一个使用裸指针的例子：
1
void process_data_raw(size_t size) {
2
int* data = new int[size]; // 获取资源
3
// 如果在这里抛出异常...
4
// 例如: if (size > 10000) throw std::runtime_error("Data size too large");
5
6
// 使用 data...
7
// 例如: for (size_t i = 0; i < size; ++i) data[i] = i * 2;
8
9
delete[] data; // 释放资源
10
} // 如果在 delete[] 前抛出异常，delete[] data 将不会被执行，导致内存泄露。
在上面的代码中，如果在 new int[size] 和 delete[] data 之间的任何位置抛出异常，delete[] data 将不会被调用，导致动态分配的内存发生泄露。这是因为栈展开 (stack unwinding) 过程中，函数会直接退出，跳过后面的清理代码。
RAII（资源获取即初始化 Resource Acquisition Is Initialization）原则提供了一种解决这类问题的方法。其核心思想是将资源的生命周期与一个对象的生命周期绑定。当对象被创建时获取资源，当对象被销毁时释放资源（通常在析构函数 (destructor) 中完成）。无论函数正常返回还是因为异常而退出，局部对象的析构函数都会被调用，从而保证资源被释放。
std::unique_ptr 就是 RAII 原则在内存管理方面的一个经典应用。它在其构造函数 (constructor) 中获取内存（通过 new 或 make_unique），并在其析构函数中释放内存（通过 delete 或 delete[]，或定制的删除器）。
使用 unique_ptr 重写上面的例子：
1
#include <memory>
2
#include <vector>
3
#include <stdexcept>
4
#include <iostream>
5
6
void process_data_unique(size_t size) {
7
// 使用 unique_ptr 管理动态分配的数组
8
std::unique_ptr<int[]> data = std::make_unique<int[]>(size); // ① 获取资源并绑定到对象
9
10
// 如果在这里抛出异常...
11
if (size > 10000) {
12
std::cerr << "Simulating exception due to large size." << std::endl;
13
throw std::runtime_error("Data size too large"); // ② 抛出异常
14
}
15
16
// 使用 data...
17
for (size_t i = 0; i < size; ++i) {
18
data[i] = static_cast<int>(i * 2);
19
}
20
std::cout << "Data processing finished." << std::endl;
21
22
// unique_ptr 在作用域结束时自动调用析构函数释放资源 (无论是否发生异常)
23
} // ③ 作用域结束，data 的析构函数被调用，delete[] data 被执行。
在 process_data_unique 函数中，即使在初始化 data 后抛出异常，std::unique_ptr<int[]> data 对象也会在其作用域结束时被销毁。unique_ptr 的析构函数会自动调用正确的 delete[] 运算符来释放所管理的内存。这保证了即使在异常发生时，内存也不会泄露。
通过将动态资源的管理委托给 unique_ptr 这样的 RAII 对象，我们可以轻松地实现强大的异常安全保证。对于由 unique_ptr 管理的资源而言，我们可以获得强异常安全保证 (strong exception guarantee)，这意味着如果操作失败（抛出异常），程序的状态会回滚到操作开始之前的状态，或者至少不会发生资源泄露。
6.2 将 unique_ptr 作为工厂函数返回值
工厂函数 (factory function) 是一种常用的创建对象的模式，特别是在需要根据运行时条件创建不同类型对象（多态 Polymorphism）或者对象的构造过程比较复杂时不直接暴露构造函数。传统的工厂函数常常返回一个裸指针，这使得调用者需要负责管理返回对象的生命周期，容易出错。
例如，一个简单的工厂函数，返回一个基类指针，指向一个派生类对象：
1
// 假设有一个基类 Base 和派生类 Derived
2
class Base {
3
public:
4
virtual ~Base() = default;
5
virtual void greet() const = 0;
6
};
7
8
class DerivedA : public Base {
9
public:
10
void greet() const override { std::cout << "Hello from DerivedA" << std::endl; }
11
};
12
13
class DerivedB : public Base {
14
public:
15
void greet() const override { std::cout << "Hello from DerivedB" << std::endl; }
16
};
17
18
// 使用裸指针的工厂函数
19
Base* create_object(int type) {
20
if (type == 1) {
21
return new DerivedA();
22
} else if (type == 2) {
23
return new DerivedB();
24
} else {
25
return nullptr; // 返回裸指针，调用者必须检查并处理
26
}
27
}
28
29
// 调用代码
30
void use_factory_raw() {
31
Base* obj = create_object(1);
32
if (obj) {
33
obj->greet();
34
delete obj; // 调用者必须记住删除
35
}
36
37
Base* obj2 = create_object(3); // 返回 nullptr
38
// 调用者需要处理 nullptr
39
// 如果忘记 delete obj 或 delete obj2 (如果非 nullptr), 就会内存泄露。
40
}
这种裸指针的方式有几个缺点：
⚝ 调用者必须记住检查返回值是否为 nullptr。
⚝ 调用者必须记住在不再需要时使用正确的 delete 运算符（对于单个对象是 delete，对于数组是 delete[]）释放内存。
⚝ 如果 create_object 返回后但在 delete 之前发生异常，资源会泄露。
将工厂函数的返回值类型改为 std::unique_ptr 可以完美解决这些问题。返回 unique_ptr 明确地向调用者表明，函数创建了一个对象，并将该对象的独占所有权 (exclusive ownership) 转移给调用者。
1
#include <memory>
2
#include <iostream>
3
4
// unique_ptr 作为返回值的工厂函数
5
std::unique_ptr<Base> create_object_smart(int type) {
6
if (type == 1) {
7
// C++14 或更高版本推荐使用 std::make_unique
8
// return std::make_unique<DerivedA>();
9
10
// C++11 可以直接用 new 构造 unique_ptr
11
return std::unique_ptr<Base>(new DerivedA()); // ① 返回一个 unique_ptr<Base>，它管理着 DerivedA 对象
12
} else if (type == 2) {
13
// return std::make_unique<DerivedB>();
14
return std::unique_ptr<Base>(new DerivedB()); // ② 返回一个 unique_ptr<Base>，它管理着 DerivedB 对象
15
} else {
16
// 返回一个空的 unique_ptr 表示失败或无效类型
17
return nullptr; // ③ 返回 nullptr，等同于返回 std::unique_ptr<Base>()
18
}
19
}
20
21
// 调用代码
22
void use_factory_smart() {
23
std::unique_ptr<Base> obj = create_object_smart(1); // ④ 接收 unique_ptr，所有权转移
24
if (obj) { // ⑤ 可以像检查裸指针一样检查 unique_ptr 是否为空
25
obj->greet();
26
} // ⑥ obj 在作用域结束时自动销毁，释放内存。
27
28
std::unique_ptr<Base> obj2 = create_object_smart(3); // 返回一个空的 unique_ptr
29
if (!obj2) {
30
std::cout << "Failed to create object of type 3." << std::endl;
31
}
32
// obj2 在作用域结束时自动销毁 (什么也不做，因为是空的)。
33
}
使用 unique_ptr 作为工厂函数返回值的好处：
⚝ 清晰的所有权语义 (clear ownership semantics)：返回值类型明确表示所有权被转移，调用者获得对返回对象的独占管理权。
⚝ 自动资源管理 (automatic resource management)：调用者不需要手动 delete，资源由 unique_ptr 的析构函数自动释放，即使在异常发生时也是如此。
⚝ 无需显式处理 nullptr 的删除：返回的 unique_ptr 可以是空的，对其调用 delete 是安全的（实际上空 unique_ptr 的析构函数什么也不做）。
⚝ 支持多态 (polymorphism)：unique_ptr<Base> 可以管理 DerivedA 或 DerivedB 对象，并且在其销毁时会通过基类的虚析构函数 (virtual destructor) 调用正确的派生类析构函数。
⚝ 高效的转移 (efficient transfer)：函数返回 unique_ptr 会利用移动语义 (move semantics)，通常通过返回值优化 (RVO - Return Value Optimization) 或命名返回值优化 (NRVO - Named Return Value Optimization) 来避免不必要的拷贝和移动，性能开销很低，接近于直接构造。
这种模式是现代 C++ 中管理动态创建对象生命周期和所有权的推荐方式。
6.3 unique_ptr 与 Pimpl (Pointer to Implementation) 模式
Pimpl 模式（Pointer to Implementation 的缩写，也称为 Handle-Body 模式）是一种软件设计技巧，用于隐藏类的实现细节，减少编译依赖，从而加快编译速度，并允许在不重新编译客户端代码的情况下修改类的实现。
其基本思想是，在类的头文件 (.h 或 .hpp) 中，只声明类的公共接口和一个指向私有实现类 (Impl) 的指针。私有实现类 Impl 的完整定义及其所有实现细节则放在 .cpp 文件中。
传统上，Pimpl 模式使用裸指针来实现：
1
// MyClass.h (头文件)
2
#include <memory> // 即使使用 unique_ptr，通常也需要包含 <memory>
3
4
class MyClass {
5
public:
6
MyClass();
7
~MyClass(); // 必须显式声明析构函数
8
9
// 不允许拷贝，只允许移动 (通常是期望的行为)
10
MyClass(const MyClass&) = delete;
11
MyClass& operator=(const MyClass&) = delete;
12
MyClass(MyClass&&); // 声明移动构造函数
13
MyClass& operator=(MyClass&&); // 声明移动赋值运算符
14
15
void do_something();
16
17
private:
18
// class Impl; // 前置声明 (forward declaration) 私有实现类
19
// Impl* pimpl_; // 使用裸指针
20
21
// 使用 unique_ptr<Impl>
22
class Impl; // 前置声明
23
std::unique_ptr<Impl> pimpl_; // ① 使用 unique_ptr 管理 Impl 对象
24
};
25
26
// MyClass.cpp (源文件)
27
#include "MyClass.h"
28
#include <iostream>
29
30
// Impl 类的完整定义放在 .cpp 文件中
31
class MyClass::Impl {
32
public:
33
void internal_do_something() {
34
std::cout << "Doing something internally." << std::endl;
35
}
36
};
37
38
// 构造函数在 .cpp 中实现
39
MyClass::MyClass() : pimpl_(std::make_unique<Impl>()) {} // ② 在构造函数中创建 Impl 对象
40
41
// 析构函数必须在 .cpp 中实现
42
MyClass::~MyClass() = default; // ③ unique_ptr 的析构函数会在这里调用 delete，因为 Impl 完整定义可见
43
44
// 移动构造函数
45
MyClass::MyClass(MyClass&& other) noexcept = default; // 默认的移动操作会移动 unique_ptr
46
47
// 移动赋值运算符
48
MyClass& MyClass::operator=(MyClass&& other) noexcept = default; // 默认的移动操作会移动 unique_ptr
49
50
// 成员函数通过 pimpl_ 调用 Impl 的方法
51
void MyClass::do_something() {
52
pimpl_->internal_do_something();
53
}
使用 std::unique_ptr 管理 Pimpl 指针相比裸指针有显著优势：
① 自动资源管理：无需手动在 MyClass 的析构函数中写 delete pimpl_。unique_ptr 会自动处理。
② 简化拷贝/移动语义：unique_ptr 是可移动但不可拷贝的。这与 Pimpl 模式的常见需求（类对象不可拷贝，但可移动）天然契合。如果 MyClass 需要支持移动语义，只需使用默认的移动构造函数和移动赋值运算符即可，它们会自动调用 unique_ptr 的移动操作。如果 MyClass 需要支持拷贝（这在 Pimpl 模式中较少见，且实现复杂，通常需要深拷贝 Impl 对象），则需要手动实现拷贝构造函数和拷贝赋值运算符。
③ 异常安全：如果 MyClass 的构造函数中除了创建 pimpl_ 外还有其他可能抛出异常的操作，使用 unique_ptr 确保 pimpl_ 指向的对象在异常发生时能够被正确销毁。
一个重要的注意事项：当使用 unique_ptr 管理一个前置声明的类型（incomplete type，如上面的 MyClass::Impl）时，该 unique_ptr 所在的类的析构函数（MyClass::~MyClass）必须在 unique_ptr 所管理类型的完整定义可见的地方实现。在我们的例子中，这意味着 MyClass::~MyClass() 必须在 MyClass.cpp 文件中实现。这是因为当编译器在 MyClass.h 中看到 ~MyClass() 的声明时，它并不知道 std::unique_ptr<Impl> 的析构函数需要调用 delete 操作符，而 delete 操作符需要知道 Impl 的完整大小和布局。只有在 MyClass.cpp 中包含了 Impl 的完整定义后，编译器才能正确地实例化 unique_ptr<Impl> 的析构函数。如果不在 .cpp 中实现析构函数（例如，在 .h 中使用 = default），编译器可能在 .h 文件编译时就尝试实例化 unique_ptr 的析构函数，此时 Impl 是不完整类型，会导致编译错误（或者链接错误，取决于具体的编译器和设置）。
使用 = default 在 .cpp 文件中实现析构函数（如 MyClass::~MyClass() = default;）是一种现代 C++ 中实现 Pimpl 模式时推荐的方式，它既利用了默认析构函数的简洁性，又满足了完整类型的要求。
6.4 在类成员中使用 unique_ptr
在类的设计中，经常会遇到一个类需要“拥有”另一个动态分配的对象作为其成员。这通常发生在以下情况：
⚝ 成员对象很大，希望避免在包含类对象本身时直接在栈上分配或进行值语义的拷贝。
⚝ 成员对象需要多态行为，即成员是一个基类指针，但实际指向派生类对象。
⚝ 成员对象的构造或生命周期管理比较复杂，需要动态控制。
使用裸指针作为类成员来管理动态资源非常麻烦，因为需要手动编写：
⚝ 析构函数，在类对象销毁时释放资源。
⚝ 拷贝构造函数，实现深拷贝 (deep copy)，避免多个对象管理同一块内存。
⚝ 拷贝赋值运算符，实现深拷贝并正确处理自赋值和旧资源的释放。
⚝ 移动构造函数和移动赋值运算符（C++11及以后），实现资源的有效转移。
任何一个遗漏或实现错误都会导致内存泄露、重复释放等严重问题。
std::unique_ptr 作为类成员则能极大地简化这一过程，因为它自动处理了资源的释放，并且其内置的移动语义（可移动但不可拷贝）通常是类成员管理动态资源所期望的行为。
例如，一个表示图形编辑器的类 Editor，可能需要一个成员来表示当前正在编辑的图形对象，这个图形对象可以是各种不同的图形类型（点、线、圆等）：
1
#include <memory>
2
#include <vector>
3
#include <iostream>
4
5
// 假设有 Shape 基类和其派生类 Circle, Square 等
6
class Shape {
7
public:
8
virtual ~Shape() = default;
9
virtual void draw() const = 0;
10
};
11
12
class Circle : public Shape {
13
public:
14
void draw() const override { std::cout << "Drawing a circle." << std::endl; }
15
};
16
17
class Square : public Shape {
18
public:
19
void draw() const override { std::cout << "Drawing a square." << std::endl; }
20
};
21
22
// 使用 unique_ptr 作为类成员
23
class Editor {
24
private:
25
// unique_ptr<Shape> 持有当前编辑的图形对象
26
std::unique_ptr<Shape> current_shape_; // ① unique_ptr 作为成员变量
27
28
public:
29
Editor() = default;
30
31
// unique_ptr 是不可拷贝的，所以 Editor 类默认也是不可拷贝的
32
// 如果需要拷贝 Editor，必须手动实现深拷贝 current_shape_ 指向的对象
33
// Editor(const Editor&) = delete; // 编译器默认会删除拷贝构造函数
34
// Editor& operator=(const Editor&) = delete; // 编译器默认会删除拷贝赋值运算符
35
36
// unique_ptr 是可移动的，所以 Editor 类默认是可移动的
37
// Editor(Editor&&) = default; // 编译器默认会生成移动构造函数
38
// Editor& operator=(Editor&&) = default; // 编译器默认会生成移动赋值运算符
39
40
// 析构函数：unique_ptr 成员会自动在其析构函数中释放资源
41
// ~Editor() = default; // 编译器默认生成的析构函数足够
42
43
void set_shape(std::unique_ptr<Shape> shape) {
44
current_shape_ = std::move(shape); // ② 转移所有权给成员变量
45
}
46
47
void create_circle() {
48
current_shape_ = std::make_unique<Circle>(); // ③ 创建新对象并赋值给 unique_ptr 成员
49
}
50
51
void create_square() {
52
current_shape_ = std::make_unique<Square>();
53
}
54
55
void draw_shape() const {
56
if (current_shape_) { // 检查 unique_ptr 是否为空
57
current_shape_->draw(); // 通过 unique_ptr 访问成员对象
58
} else {
59
std::cout << "No shape to draw." << std::endl;
60
}
61
}
62
63
// 可以在需要时获取裸指针与 C API 交互，但要小心
64
Shape* get_raw_shape() const {
65
return current_shape_.get(); // ④ 获取裸指针
66
}
67
};
68
69
// 示例使用
70
void use_editor() {
71
Editor editor;
72
editor.create_circle();
73
editor.draw_shape(); // Drawing a circle.
74
75
editor.create_square(); // 旧的 Circle 对象被自动销毁
76
editor.draw_shape(); // Drawing a square.
77
78
// 转移 unique_ptr 所有权给 Editor
79
std::unique_ptr<Shape> my_custom_shape = std::make_unique<Circle>();
80
editor.set_shape(std::move(my_custom_shape));
81
editor.draw_shape(); // Drawing a circle.
82
83
} // editor 对象销毁，其成员 current_shape_ 也销毁，释放管理的 Shape 对象。
在这个例子中：
⚝ Editor 类不再需要手动编写析构函数来释放 current_shape_ 指向的对象。unique_ptr 的析构函数会自动处理。
⚝ 由于 unique_ptr 是不可拷贝的，编译器会默认禁用 Editor 类的拷贝构造函数和拷贝赋值运算符。这强制了 Editor 对象的独占性，通常符合类设计中某个成员是独占资源的情况。
⚝ Editor 类是可移动的，因为 unique_ptr 是可移动的。默认生成的移动构造函数和移动赋值运算符会正确地移动 current_shape_ 的所有权。
⚝ 通过 set_shape 函数，可以清晰地将外部创建的 unique_ptr 的所有权转移给 Editor 的成员。
⚝ 通过 create_circle/create_square 函数，可以直接在成员 unique_ptr 中创建并持有新的对象。
使用 unique_ptr 作为类成员是管理类内部独占动态资源的标准和推荐方式。它显著提高了代码的安全性、简洁性和正确性。
6.5 避免常见的 unique_ptr 错误
虽然 unique_ptr 大大简化了内存管理，但如果不正确使用其某些成员函数或不理解其所有权语义，仍然可能引入错误。了解这些常见错误并知道如何避免它们至关重要。
① 错误：调用 release() 后忘记 delete 返回的裸指针
release() 方法会放弃 unique_ptr 对其所管理资源的控制权，并返回该资源的裸指针。unique_ptr 随后变为空。调用 release() 后，资源的销毁责任完全转移给了调用者。如果调用者没有显式地 delete 返回的指针，就会发生内存泄露。
1
#include <memory>
2
#include <iostream>
3
4
void demo_release_error() {
5
auto ptr = std::make_unique<int>(10);
6
int* raw_ptr = ptr.release(); // ① 释放所有权并获取裸指针
7
std::cout << "Value: " << *raw_ptr << std::endl;
8
// ... 使用 raw_ptr ...
9
10
// 错误！忘记了 delete raw_ptr; 这会导致内存泄露。
11
// 正确做法是: delete raw_ptr;
12
} // ② ptr 在这里销毁，但它已经不拥有资源，什么也不做。
如何避免：
⚝ 大多数情况下，不需要调用 release()。如果你的目的是将资源管理交给另一个智能指针或另一个 RAII 对象，或者只是临时需要裸指针访问，通常有更好的方式（如使用 std::move 转移给另一个 unique_ptr/shared_ptr，或使用 get() 获取临时裸指针）。
⚝ 如果确实需要将资源的所有权交出去，请确保接收方明确知道需要接管删除责任，或者立即将其包装到另一个智能指针中。
② 错误：使用 get() 获取裸指针后，手动 delete 该裸指针
get() 方法返回 unique_ptr 所管理的资源的裸指针，但它不释放所有权。unique_ptr 仍然拥有该资源，并在其生命周期结束时尝试删除它。如果在 unique_ptr 销毁之前，你对 get() 返回的裸指针调用了 delete，会导致同一块内存被删除两次，即重复释放 (double free)，这是未定义行为 (undefined behavior)。
1
#include <memory>
2
#include <iostream>
3
4
void demo_get_delete_error() {
5
auto ptr = std::make_unique<int>(20);
6
int* raw_ptr = ptr.get(); // ① 获取裸指针，但不释放所有权
7
8
// 错误！ptr 仍然拥有资源，delete raw_ptr; 会导致重复释放。
9
// delete raw_ptr; // 绝对不要这样做！
10
11
std::cout << "Value via raw_ptr: " << *raw_ptr << std::endl;
12
} // ② ptr 在这里销毁，它尝试删除之前用 make_unique 创建的资源。
13
// 如果上面手动 delete 了，这里就会重复删除。
如何避免：
⚝ 永远不要对从 get() 方法获得的裸指针调用 delete。
⚝ get() 通常用于需要与接受裸指针的旧 C 或 C++ API 交互的场景。在使用 get() 返回的指针时，要记住它的生命周期受原始 unique_ptr 控制。
③ 错误：创建多个 unique_ptr 管理同一个裸指针
unique_ptr 强调独占所有权。如果你使用同一个裸指针构造了多个 unique_ptr，它们都会认为自己拥有这块内存。当这些 unique_ptr 对象销毁时，它们都会尝试删除这块内存，导致重复释放。
1
#include <memory>
2
#include <iostream>
3
4
void demo_multiple_ownership_error() {
5
int* raw_ptr = new int(30);
6
7
std::unique_ptr<int> ptr1(raw_ptr); // ① ptr1 认为它拥有 raw_ptr
8
// std::unique_ptr<int> ptr2(raw_ptr); // ② 错误！ptr2 也试图拥有 raw_ptr，违反独占性。
9
// 通常编译可能通过，但运行时会出错（重复释放）。
10
11
// 如果强行这样做 (例如通过 reset()):
12
std::unique_ptr<int> ptr3;
13
// ptr3.reset(raw_ptr); // ③ 错误！ptr3 也试图拥有 raw_ptr。
14
15
} // ④ ptr1 (以及可能的 ptr2, ptr3) 在这里销毁，尝试删除 raw_ptr 指向的内存。
如何避免：
⚝ 只使用 std::make_unique 或 std::unique_ptr(new T(...)) 来创建 unique_ptr，直接从 new 表达式获取所有权。
⚝ 如果必须从现有的裸指针创建 unique_ptr，请确保该裸指针之前没有被任何其他智能指针或手动管理的代码所拥有，并且在你创建 unique_ptr 后，你将不再手动管理该裸指针。这种做法通常被认为是危险的，应尽量避免。
④ 错误：试图拷贝 unique_ptr
unique_ptr 显式地删除了拷贝构造函数和拷贝赋值运算符，以 enforcing 其独占所有权。试图拷贝一个 unique_ptr 会导致编译错误。
1
#include <memory>
2
3
void demo_copy_error() {
4
auto ptr1 = std::make_unique<int>(40);
5
// std::unique_ptr<int> ptr2 = ptr1; // 错误！Attempting to copy a unique_ptr.
6
// std::unique_ptr<int> ptr3;
7
// ptr3 = ptr1; // 错误！Attempting to copy-assign a unique_ptr.
8
}
如何避免：
⚝ 如果你需要转移 unique_ptr 的所有权，请使用 std::move。
⚝ 如果你需要多个智能指针共享同一块内存的所有权，请使用 std::shared_ptr。
⑤ 错误：使用 unique_ptr<T> 管理数组，或使用 unique_ptr<T[]> 管理单个对象
unique_ptr 有针对单个对象 (unique_ptr<T>) 和数组 (unique_ptr<T[]>) 的特化版本。这两种特化版本使用不同的删除器：unique_ptr<T> 使用默认的 delete，而 unique_ptr<T[]> 使用默认的 delete[]。使用错误的特化版本会导致未定义行为。
1
#include <memory>
2
#include <iostream>
3
4
void demo_array_mismatch_error() {
5
// 错误！试图用 unique_ptr<T> 管理数组
6
// std::unique_ptr<int> array_ptr(new int[5]); // ① 会使用 delete 而非 delete[]，未定义行为。
7
8
// 错误！试图用 unique_ptr<T[]> 管理单个对象
9
// std::unique_ptr<int[]> single_ptr(new int(50)); // ② 会使用 delete[] 而非 delete，未定义行为。
10
11
// 正确做法：
12
std::unique_ptr<int[]> correct_array_ptr = std::make_unique<int[]>(5); // 管理数组
13
std::unique_ptr<int> correct_single_ptr = std::make_unique<int>(50); // 管理单个对象
14
}
如何避免：
⚝ 使用 std::make_unique<T[]>(size) 创建和管理数组。
⚝ 使用 std::make_unique<T>(...) 创建和管理单个对象。
⚝ 从裸指针构造时，确保使用正确的 unique_ptr<T> 或 unique_ptr<T[]> 特化版本。
⑥ 错误：与不完整类型 (incomplete type) 一起使用 unique_ptr，并且该类型的析构函数在其完整定义不可见的地方调用
正如在 Pimpl 模式中讨论的，如果你使用 unique_ptr 管理一个前置声明的类型 T (class T;)，那么包含这个 unique_ptr<T> 成员的类的析构函数必须在 T 的完整定义可见的地方实现。这是因为 unique_ptr<T> 的默认删除器需要调用 delete，而 delete 操作符需要知道 T 的完整定义来正确销毁对象。如果在 T 是不完整类型时调用 unique_ptr<T> 的析构函数（例如，包含类的析构函数在头文件中默认实现），会导致编译或链接错误。
1
// MyClass.h
2
class Impl; // 不完整类型
3
4
class MyClass {
5
std::unique_ptr<Impl> pimpl_;
6
public:
7
MyClass();
8
// ~MyClass() = default; // 错误！Impl 在这里是不完整类型
9
};
10
11
// MyClass.cpp
12
#include "MyClass.h"
13
14
class Impl { /* ... Impl 的完整定义 ... */ };
15
16
MyClass::MyClass() : pimpl_(std::make_unique<Impl>()) {}
17
18
// MyClass::~MyClass() = default; // 正确！在 Impl 的完整定义可见的地方实现析构函数
如何避免：
⚝ 如果类中使用了 unique_ptr 来管理一个前置声明的不完整类型，请确保该类的析构函数在其 .cpp 文件中实现（即使是使用 = default）。
掌握这些常见错误及其避免方法，将帮助你更自信、更正确地使用 std::unique_ptr，充分利用其提供的内存安全和代码简洁性。
7. 性能与注意事项
本章分析 unique_ptr 的性能开销，并讨论与线程安全相关的考虑事项。通过本章的学习，读者将能更全面地理解 unique_ptr 的实际应用场景及其潜在的限制。
7.1 unique_ptr 的性能开销
本节分析 unique_ptr 在运行时通常接近于裸指针的零开销特性。理解 unique_ptr 的性能特点对于在性能敏感的应用中做出明智的设计选择至关重要。
智能指针的设计目标之一就是在提供自动化资源管理的同时，尽量减少额外的运行时开销。对于 std::unique_ptr 而言，这一目标实现得非常出色。
① 运行时开销 (Runtime Overhead)
▮▮▮▮unique_ptr 的核心功能是保证资源在其作用域结束或所有权被明确转移时被释放。这个释放操作本质上是调用底层裸指针的删除器 (deleter)，对于默认删除器而言，就是简单地调用 delete 或 delete[]。
▮▮▮▮在使用 unique_ptr 访问底层资源时（通过 operator* 或 operator->），其行为与裸指针完全相同，通常会被编译器优化到与直接使用裸指针没有区别，即“零开销抽象 (zero-cost abstraction)”。
▮▮▮▮与 std::shared_ptr 不同，unique_ptr 不涉及引用计数 (reference counting) 的原子操作或管理块 (control block) 的开销。这意味着在创建、拷贝（unique_ptr 不可拷贝）、赋值（转移所有权）、析构等操作上，unique_ptr 的开销远小于 shared_ptr。其移动操作 (move operation) 通常也只是简单的指针赋值。
② 存储开销 (Storage Overhead)
▮▮▮▮一个 unique_ptr 对象通常只需要存储一个指针，其大小与裸指针相同。
▮▮▮▮如果使用了定制删除器 (custom deleter)，存储开销可能会有所增加。
▮▮▮▮▮▮▮▮⚝ 如果删除器是无状态的 (stateless)，例如函数指针 (function pointer) 或空的 Lambda 表达式，编译器通常可以将删除器类型优化掉，unique_ptr 的大小仍然是一个指针。
▮▮▮▮▮▮▮▮⚝ 如果删除器是有状态的 (stateful)，例如一个包含成员变量的函数对象 (functor) 或捕获了变量的 Lambda 表达式，那么 unique_ptr 的大小会是底层指针的大小加上删除器对象的大小。然而，C++ 标准库实现通常会利用空基类优化 (Empty Base Optimization)，如果删除器是空的，其大小不会额外增加。
③ std::make_unique 的优势
▮▮▮▮优先使用 std::make_unique (C++14 及以后) 而不是直接使用 new 来构造 unique_ptr 有额外的性能和安全优势。
▮▮▮▮▮▮▮▮⚝ 异常安全 (Exception Safety): 当函数调用中包含多个表达式，其中既有资源分配又有其他可能抛出异常的操作时，直接使用 new 后立即创建 unique_ptr 可能存在异常安全问题导致内存泄漏。例如 Foo(std::unique_ptr<T>(new T()), func())，如果 func() 抛出异常，new T() 分配的内存在创建 unique_ptr 之前可能得不到释放。std::make_unique<T>() 将对象创建和 unique_ptr 构造合并为一个操作，保证了原子性。
▮▮▮▮▮▮▮▮⚝ 性能/代码简洁性: std::make_unique 避免了两次内存分配（一次对象本身，一次智能指针的管理块——尽管 unique_ptr 没有管理块，但 make_unique 仍然是推荐的模式，并且对于 shared_ptr 来说可以避免两次分配）。对于 unique_ptr 而言，其主要优势在于异常安全和代码简洁。
总的来说，在绝大多数情况下，使用 unique_ptr 管理动态分配的对象，其运行时性能可以与使用裸指针相媲美，甚至在考虑异常安全和资源释放的健壮性方面，unique_ptr 是更优的选择，因为它消除了手动管理带来的潜在错误和调试成本。
7.2 unique_ptr 与异常安全
本节重申 unique_ptr 在保证异常安全 (exception safety) 方面的关键作用。理解这一点对于编写健壮可靠的 C++ 代码至关重要。
在 C++ 中，当函数执行过程中发生异常 (exception) 并被抛出时，会触发栈展开 (stack unwinding) 机制。在栈展开过程中，当前作用域内的局部对象会被按照与构造顺序相反的顺序依次销毁，它们的析构函数 (destructor) 会被调用。RAII（资源获取即初始化 Resource Acquisition Is Initialization）原则正是利用了这一机制。
① 裸指针的异常安全问题
▮▮▮▮考虑以下使用裸指针的代码示例：
1
void process_data(DataSource* source);
2
3
void dangerous_function() {
4
MyObject* obj = new MyObject(); // 分配资源
5
process_data(obj); // 可能抛出异常
6
delete obj; // 释放资源
7
}
▮▮▮▮在这个例子中，如果在 process_data(obj) 调用过程中抛出了异常，那么 delete obj; 这一行代码将永远不会被执行到。结果就是 obj 指向的内存发生了内存泄漏 (memory leak)。
② unique_ptr 如何确保异常安全
▮▮▮▮使用 unique_ptr 管理资源后，代码变成这样：
1
#include <memory>
2
3
void process_data(DataSource* source); // 函数接口可能仍需要裸指针
4
5
void safe_function() {
6
std::unique_ptr<MyObject> obj_ptr(new MyObject()); // 使用 unique_ptr 管理资源
7
// 或者更好的方式 (C++14+):
8
// std::unique_ptr<MyObject> obj_ptr = std::make_unique<MyObject>();
9
10
process_data(obj_ptr.get()); // 调用可能抛出异常的函数，使用 get() 获取裸指针
11
12
// unique_ptr 会在其作用域结束时（无论正常退出还是异常退出）自动调用析构函数释放资源
13
} // obj_ptr 在这里超出作用域，其析构函数被调用，自动执行 delete
▮▮▮▮在这个例子中，即使 process_data(obj_ptr.get()) 抛出异常，栈展开机制也会确保 safe_function 中的局部对象 obj_ptr 在销毁前被正确析构。unique_ptr 的析构函数会负责调用 delete 释放其管理的内存。因此，无论函数是正常完成还是因异常退出，资源都能得到及时释放，从而避免了内存泄漏，实现了强大的异常安全保证。
③ RAII 的体现
▮▮▮▮unique_ptr 是 RAII 原则在内存管理上的典型应用。它将资源的生命周期（内存的分配与释放）与对象的生命周期（unique_ptr 对象的创建与销毁）绑定在一起。当 unique_ptr 对象被创建时（资源被获取），它拥有资源；当 unique_ptr 对象被销毁时（例如超出作用域或被删除），它会自动释放所拥有的资源。这种机制使得资源管理变得自动化和异常安全。
通过依赖 unique_ptr 的自动资源管理，开发者可以极大地简化异常处理逻辑，将更多精力放在业务逻辑上，而不是繁琐的资源清理代码，写出更清晰、更健壮的代码。
7.3 unique_ptr 的线程安全
本节说明 unique_ptr 对象本身不提供线程安全访问，但可以安全地在线程之间转移所有权。理解 unique_ptr 的线程安全属性对于并发编程至关重要。
在 C++ 并发编程中，线程安全 (thread safety) 是一个重要的概念。它通常指的是在多线程环境下，某个数据结构或函数可以被多个线程同时访问而不会导致数据竞争 (data race) 或不一致的状态。
① unique_ptr 对象本身的线程安全
▮▮▮▮std::unique_ptr 对象本身就像其他大多数 C++ 标准库对象一样，对于同一个 unique_ptr 对象的并发修改是不安全的。
▮▮▮▮例如，如果两个线程同时尝试调用同一个 unique_ptr 对象的 reset() 方法或对其进行移动赋值，而没有外部同步机制（如互斥锁 mutex），就会发生数据竞争，导致未定义行为 (undefined behavior)。
1
std::unique_ptr<MyObject> shared_unique_ptr = std::make_unique<MyObject>();
2
3
// Thread 1:
4
// shared_unique_ptr.reset(); // Data race!
5
6
// Thread 2:
7
// auto another_ptr = std::move(shared_unique_ptr); // Data race!
▮▮▮▮因此，如果多个线程需要访问或修改同一个 unique_ptr 对象，必须使用互斥锁或其他同步原语来保护对该对象的访问。
② unique_ptr 管理的资源的线程安全
▮▮▮▮unique_ptr 管理的底层资源（即 unique_ptr 指向的对象）的线程安全取决于该对象本身的性质。
▮▮▮▮如果 unique_ptr 指向一个需要在多个线程间共享且可能被同时修改的对象，那么访问该对象（通过 get() 获取裸指针或通过 * / -> 解引用）同样需要外部同步，即使 unique_ptr 对象本身没有被多个线程同时修改。
▮▮▮▮不过，由于 unique_ptr 强调独占所有权 (exclusive ownership)，它天然地倾向于单线程管理或在线程间转移所有权，这在一定程度上简化了线程安全的设计。
③ 所有权在线程间的转移
▮▮▮▮unique_ptr 的核心特性是其所有权可以被转移 (move)。这种所有权的转移操作本身（即 std::move 后进行赋值或作为函数参数/返回值）通常被设计为可以安全地跨越线程边界。
▮▮▮▮这意味着你可以将一个 unique_ptr 从一个线程移动到另一个线程，从而安全地将资源的管理责任从一个线程转移到另一个线程。例如，可以将一个 unique_ptr 放入一个线程安全的队列 (thread-safe queue)，然后在另一个线程中从队列中取出该 unique_ptr，从而将资源的所有权从生产者线程转移到消费者线程。
1
std::unique_ptr<MyObject> create_object_in_thread1() {
2
// ... create object ...
3
return std::make_unique<MyObject>(/*...*/); // 所有权通过返回值移动
4
}
5
6
void process_object_in_thread2(std::unique_ptr<MyObject> obj_ptr) {
7
// 接收所有权，在该线程中使用和释放对象
8
// ... process object ...
9
} // obj_ptr 在此超出作用域并释放资源
▮▮▮▮在这种所有权转移的模式下，资源在任何时刻都只被一个 unique_ptr 对象拥有，消除了多个智能指针对象同时管理同一个资源带来的复杂性。
总结来说，unique_ptr 对象本身不是线程安全的，不能被多个线程同时修改。但它管理的资源是否线程安全取决于资源本身的类型和使用方式。unique_ptr 的独占所有权和移动语义使其成为在线程间安全转移资源所有权的理想工具。
7.4 与旧代码的交互：获取裸指针
本节讨论在需要与使用裸指针的旧 API (legacy API) 交互时，如何安全地使用 unique_ptr 的 get() 方法。这是在现代 C++ 项目中集成旧代码时经常遇到的场景。
在实际开发中，我们经常需要调用一些遗留的 C 或 C++ 库函数，这些函数通常接收或返回裸指针 (raw pointer)。当我们的资源由 unique_ptr 管理时，就需要一种方法来向这些函数提供它们期望的裸指针。unique_ptr::get() 方法正是为此目的而生。
① unique_ptr::get() 方法
▮▮▮▮unique_ptr::get() 方法返回 unique_ptr 当前管理的对象的底层裸指针。
▮▮▮▮关键点: 调用 get() 方法不会转移 unique_ptr 对资源的所有权。unique_ptr 仍然拥有并负责最终释放该资源。
▮▮▮▮这使得 get() 方法非常适合用于将裸指针传递给不获取所有权，而仅仅是访问或修改底层对象的函数。
1
#include <memory>
2
#include <iostream>
3
4
// 遗留函数，接收裸指针但不对其进行 delete
5
void process_raw_pointer(int* data) {
6
if (data) {
7
std::cout << "Processing data: " << *data << std::endl;
8
// 重要的警告：不要在这里 delete data;
9
}
10
}
11
12
int main() {
13
std::unique_ptr<int> managed_int = std::make_unique<int>(100);
14
15
// 使用 get() 将裸指针传递给遗留函数
16
process_raw_pointer(managed_int.get());
17
18
std::cout << "Managed int is still valid: " << *managed_int << std::endl; // unique_ptr 仍然有效
19
20
// managed_int 在 main 函数结束时超出作用域，内存会被 unique_ptr 自动释放
21
return 0;
22
}
▮▮▮▮在上面的示例中，process_raw_pointer 函数通过 get() 获取裸指针 100，进行处理，但它不负责内存释放。内存的释放仍然由 managed_int 这个 unique_ptr 负责，在其生命周期结束时自动完成。
② 使用 get() 的注意事项
▮▮▮▮使用 get() 方法时，最重要也是最容易犯的错误是使用 get() 返回的裸指针访问资源，而该资源已经被其对应的 unique_ptr 释放或不再管理。
▮▮▮▮考虑以下错误示例：
1
#include <memory>
2
3
// 遗留函数... 同上
4
5
void unsafe_usage() {
6
std::unique_ptr<int> managed_int = std::make_unique<int>(200);
7
int* raw_ptr = managed_int.get(); // 获取裸指针
8
9
// 现在改变 unique_ptr 管理的状态，使其不再拥有资源
10
managed_int.reset(); // 资源被释放
11
12
// WARNING: 使用 raw_ptr 是未定义行为！它现在是一个野指针 (dangling pointer)
13
// *raw_ptr = 300; // 危险操作！
14
// process_raw_pointer(raw_ptr); // 危险操作！
15
} // managed_int 在这里超出作用域，但它已经不管理资源了
▮▮▮▮在这种情况下，一旦 managed_int.reset() 被调用，unique_ptr 就会释放它之前管理的内存，此时 raw_ptr 变成一个指向已释放内存的野指针。任何通过 raw_ptr 对该内存的访问都是非法的，会导致程序崩溃或产生难以预料的行为。
▮▮▮▮因此，通过 get() 获取的裸指针的生命周期绝对不能超过管理它的 unique_ptr 对象的生命周期。这种裸指针仅应用于临时传递给需要裸指针参数的函数。
③ 与 release() 的区别
▮▮▮▮与 get() 不同，unique_ptr::release() 方法会放弃 unique_ptr 对资源的所有权，并返回其管理的裸指针。
▮▮▮▮关键点: 调用 release() 后，unique_ptr 将变为空，不再负责释放资源。此时，开发者必须自行负责通过返回的裸指针释放资源（通常是调用 delete 或 delete[]）。
1
#include <memory>
2
#include <iostream>
3
4
// 遗留函数，接收裸指针并**期望**调用者负责后续释放
5
void process_and_transfer_ownership(int* data); // 假设这个函数不释放内存
6
7
// 遗留函数，接收裸指针并**期望**由它自己内部释放
8
void process_and_delete_internally(int* data);
9
10
int main() {
11
std::unique_ptr<int> managed_int = std::make_unique<int>(400);
12
13
// 如果遗留函数不负责释放，只读/写：使用 get()
14
process_raw_pointer(managed_int.get());
15
16
// 如果遗留函数也不负责释放，且需要转移所有权（较少见，通常用unique_ptr移动）：
17
// process_and_transfer_ownership(managed_int.release()); // 不常见且危险，除非明确知道如何处理返回的裸指针
18
// 现在 managed_int 为空，你必须手动 delete raw_ptr 如果 process_and_transfer_ownership 没有处理它
19
20
// 如果遗留函数负责释放：使用 release() 将所有权转移给它
21
// 例如，假设有一个 C API 函数，需要一个通过 malloc 分配的指针，并在内部 free
22
// unique_ptr 默认使用 delete，所以这种直接 release 给 C free 函数的情况很少见，除非你用了定制删除器
23
// 但是，如果旧代码需要获取所有权并在其内部负责释放，可以使用 release()
24
// process_and_delete_internally(managed_int.release());
25
// 现在 managed_int 为空，且资源已由 process_and_delete_internally 负责释放
26
27
return 0;
28
}
▮▮▮▮通常，在与旧代码交互时，如果旧代码仅仅需要访问数据而不负责释放，使用 get() 是正确且安全的做法。只有在明确需要将资源的所有权转移给旧代码或某个 C API 时，才应该考虑使用 release()，并且必须非常谨慎地管理 release() 返回的裸指针的生命周期。在现代 C++ 中，尽量将资源封装在智能指针内部，避免在核心逻辑中直接操作裸指针。
8. 案例分析与实战应用
本章将通过一系列具体的代码示例和实际场景，展示 std::unique_ptr 在现代 C++ 项目中的强大功能和应用价值。理解这些案例将帮助读者更好地将 unique_ptr 的概念转化为实践，编写更安全、更高效的代码。
8.1 在数据结构中管理动态对象
动态数据结构，如链表（linked list）、树（tree）、图（graph）等，通常涉及动态分配节点（node）对象。在 C++ 中，使用裸指针（raw pointer）管理这些节点的内存极易出错，导致内存泄漏（memory leak）或重复释放（double free）。std::unique_ptr 提供了独占所有权（exclusive ownership）的语义，非常适合用于管理这些具有清晰、单一所有者的动态节点。
例如，考虑构建一个简单的单向链表（singly linked list）。链表中的每个节点拥有指向下一个节点的唯一所有权。
1
#include <iostream>
2
#include <memory>
3
#include <utility> // For std::move
4
5
// 定义链表节点
6
struct Node {
7
int data;
8
std::unique_ptr<Node> next; // 使用 unique_ptr 管理下一个节点的内存
9
10
// 构造函数
11
Node(int val) : data(val), next(nullptr) {
12
std::cout << "节点 " << data << " 创建。\n";
13
}
14
15
// 析构函数
16
~Node() {
17
std::cout << "节点 " << data << " 销毁。\n";
18
// unique_ptr 的析构会自动处理 next 指向的节点，形成递归销毁
19
}
20
21
// 节点插入（在当前节点后插入）
22
void insert_after(int val) {
23
// 创建新节点
24
auto new_node = std::make_unique<Node>(val);
25
// 转移当前节点的 next 指针的所有权给新节点
26
new_node->next = std::move(next);
27
// 将新节点的所有权转移给当前节点的 next
28
next = std::move(new_node);
29
}
30
31
// 删除当前节点后的节点
32
std::unique_ptr<Node> remove_after() {
33
if (!next) {
34
return nullptr; // 没有下一个节点
35
}
36
// 转移下一个节点的所有权并返回
37
return std::move(next);
38
}
39
};
40
41
// 链表类
42
class LinkedList {
43
private:
44
std::unique_ptr<Node> head; // 使用 unique_ptr 管理头节点
45
46
public:
47
// 构造函数
48
LinkedList() : head(nullptr) {}
49
50
// 析构函数（unique_ptr 的析构会自动链式销毁所有节点）
51
~LinkedList() {
52
std::cout << "链表销毁。\n";
53
}
54
55
// 在链表头部插入节点
56
void push_front(int val) {
57
auto new_node = std::make_unique<Node>(val);
58
// 转移当前 head 的所有权给新节点的 next
59
new_node->next = std::move(head);
60
// 将新节点的所有权转移给 head
61
head = std::move(new_node);
62
}
63
64
// 遍历链表并打印
65
void display() const {
66
const Node* current = head.get(); // 使用 get() 获取裸指针进行只读访问
67
std::cout << "链表内容: ";
68
while (current) {
69
std::cout << current->data << " -> ";
70
current = current->next.get();
71
}
72
std::cout << "nullptr\n";
73
}
74
75
// 获取头节点的所有权 (危险操作，通常不推荐)
76
// std::unique_ptr<Node> pop_front() {
77
// if (!head) {
78
// return nullptr;
79
// }
80
// // 转移 head 的所有权并返回
81
// return std::move(head);
82
// }
83
};
84
85
int main() {
86
LinkedList list;
87
88
list.push_front(30);
89
list.push_front(20);
90
list.push_front(10);
91
92
list.display();
93
94
// 退出作用域时，list 对象及其 head unique_ptr 将被销毁，
95
// unique_ptr 的析构会递归地销毁所有节点，无需手动 delete。
96
// 这体现了 RAII 和 unique_ptr 的自动资源管理优势。
97
98
// 示例：在第一个节点（10）后插入 15
99
if (list.head) { // 确保链表不为空
100
list.head->insert_after(15);
101
}
102
list.display();
103
104
// 示例：删除第一个节点（10）后的节点（15）
105
if (list.head && list.head->next) {
106
auto removed_node = list.head->remove_after();
107
std::cout << "已移除节点: " << removed_node->data << std::endl;
108
}
109
list.display();
110
111
112
return 0;
113
} // list 在这里超出作用域并被销毁
代码解析:
⚝ 链表节点 Node 的 next 成员被声明为 std::unique_ptr<Node>。这明确表达了当前节点“拥有”下一个节点的内存。
⚝ 节点的构造函数中，next 初始化为 nullptr，表示最初不拥有任何后续节点。
⚝ 节点的析构函数会打印消息，更重要的是，当 Node 对象被销毁时，其 unique_ptr<Node> next 成员的析构函数会被调用。如果 next 指向一个有效的 Node 对象，那么该对象的析构函数也会被调用，以此类推，形成一个自动的递归销毁过程，无需手动编写循环来释放每个节点。
⚝ 在 insert_after 方法中，使用 std::make_unique 创建新节点，并利用 std::move 转移所有权来改变链表结构，而不是进行拷贝。
⚝ 在 remove_after 方法中，同样使用 std::move 将被删除节点的所有权转移给调用者，或者如果不需要返回被删除节点， simply letting next go out of scope and be destroyed would also work.
⚝ 链表类 LinkedList 的 head 成员也是 std::unique_ptr<Node>，管理链表的头节点。当 LinkedList 对象被销毁时，其 head unique_ptr 被销毁，从而启动了整个链表的自动销毁过程。
⚝ push_front 方法演示了如何在链表头部插入新节点，通过 std::move 巧妙地转移了原头节点的所有权。
⚝ display 方法中使用 head.get() 获取裸指针进行遍历。这是安全的，因为 get() 只提供一个观测用的指针，不会转移或影响所有权，并且在 unique_ptr 的生命周期内是有效的。
⚝ 主函数 main 中创建 LinkedList 对象并进行操作。当 main 函数结束时，list 对象超出作用域，其析构函数被调用，自动清理了整个链表。
使用 unique_ptr 管理动态数据结构的好处:
① 内存安全: 避免了手动 delete 的繁琐和易错性，消除了内存泄漏和重复释放的风险。
② 异常安全: 如果在操作过程中发生异常，已由 unique_ptr 管理的内存会被正确释放，保证了基本的异常安全（exception safety）。
③ 清晰的所有权语义: 代码明确表达了哪个对象拥有资源的控制权，提高了代码的可读性和可维护性。
④ 性能: unique_ptr 几乎没有运行时开销，其大小通常与裸指针相同，移动操作通常是零开销的指针赋值。
除了链表，unique_ptr 也非常适用于管理树结构中的子节点、图结构中的边对象（如果边有明确的独占所有者）等动态分配的对象。关键在于识别资源（动态分配的对象）是否具有唯一的所有者。
8.2 管理文件句柄或系统资源
std::unique_ptr 不仅限于管理堆内存，它实际上可以管理任何资源，只要能够为其提供一个合适的删除器（deleter）。定制删除器（custom deleter）是 unique_ptr 的一个强大特性，允许我们定义资源释放时执行的特定操作，而不仅仅是默认的 delete 或 delete[]。
许多系统资源，如文件句柄 (FILE* in C)、互斥锁（mutex）、套接字（socket）、动态链接库句柄（DLL handle）等，都需要在使用完毕后调用特定的释放函数（如 fclose, pthread_mutex_destroy, closesocket, FreeLibrary 等）。这些资源的生命周期管理同样遵循 RAII 原则，可以利用 unique_ptr 和定制删除器来实现自动管理。
示例：使用定制删除器管理 C 风格的文件句柄 FILE*
在 C 语言中，文件是通过 FILE* 句柄表示的，需要用 fopen 打开，用 fclose 关闭。手动管理 fclose 很容易遗忘，尤其是在存在分支或异常的复杂逻辑中。
我们可以定义一个定制删除器，让 unique_ptr 来自动调用 fclose。
1
#include <cstdio> // For FILE, fopen, fclose
2
#include <memory>
3
#include <iostream>
4
5
// 定义一个函数对象（functor）作为定制删除器
6
struct FileCloser {
7
void operator()(FILE* file) const {
8
if (file) {
9
std::cout << "调用 fclose 关闭文件。\n";
10
fclose(file); // 调用 C 库函数关闭文件
11
}
12
}
13
};
14
15
// 定义一个函数作为定制删除器（另一种方式）
16
void close_file_func(FILE* file) {
17
if (file) {
18
std::cout << "调用 close_file_func 关闭文件。\n";
19
fclose(file);
20
}
21
}
22
23
24
int main() {
25
std::cout << "--- 使用函数对象作为删除器 ---\n";
26
{ // 作用域开始
27
// 使用 unique_ptr 管理 FILE*，并指定定制删除器 FileCloser
28
// unique_ptr<FILE*, FileCloser> file_ptr(fopen("my_file_functor.txt", "w"));
29
// C++14 make_unique 不能直接用于裸指针和定制删除器，需要手动构造或 C++20
30
// For C++11/14/17, manual construction or helper function is needed.
31
// Let's use manual construction here:
32
std::unique_ptr<FILE, FileCloser> file_ptr(fopen("my_file_functor.txt", "w"));
33
34
35
if (file_ptr) {
36
// 文件打开成功
37
std::cout << "文件 my_file_functor.txt 打开成功。\n";
38
fprintf(file_ptr.get(), "Hello from unique_ptr with functor deleter!\n");
39
// unique_ptr 会在其作用域结束时自动调用 FileCloser(file_ptr.get())
40
} else {
41
std::cerr << "无法打开文件 my_file_functor.txt\n";
42
}
43
} // file_ptr 在这里超出作用域，FileCloser() 被调用，fclose 被执行
44
std::cout << "--- 作用域结束，文件已自动关闭 ---\n";
45
46
std::cout << "\n--- 使用函数指针作为删除器 ---\n";
47
{ // 另一个作用域
48
// 使用 unique_ptr 管理 FILE*，并指定定制删除器函数指针
49
// 这里的类型是 unique_ptr<FILE, void(*)(FILE*)>
50
std::unique_ptr<FILE, void(*)(FILE*)> file_ptr_func(fopen("my_file_func.txt", "w"), &close_file_func);
51
52
if (file_ptr_func) {
53
std::cout << "文件 my_file_func.txt 打开成功。\n";
54
fprintf(file_ptr_func.get(), "Hello from unique_ptr with function pointer deleter!\n");
55
// unique_ptr 会在其作用域结束时自动调用 close_file_func(file_ptr_func.get())
56
} else {
57
std::cerr << "无法打开文件 my_file_func.txt\n";
58
}
59
} // file_ptr_func 在这里超出作用域，close_file_func() 被调用，fclose 被执行
60
std::cout << "--- 作用域结束，文件已自动关闭 ---\n";
61
62
// 注意：使用 std::unique_ptr<FILE, Deleter> 时，FILE* 是底层指针类型。
63
// unique_ptr 的模板参数是管理的**对象类型**，不是指针类型。
64
// 所以是 unique_ptr<FILE, ...> 而不是 unique_ptr<FILE*, ...>。
65
// 底层指针类型是 unique_ptr 模板的第二个参数 Deleter::pointer_type，
66
// 默认是 T*。如果 Deleter 有一个 pointer_type 的 typedef，则使用该类型。
67
// 例如，std::default_delete<T> 定义了 pointer_type 为 T*。
68
// 对于 FILE*，直接使用 FILE 作为类型 T 通常是有效的。
69
// 另一种常见做法是特化 std::default_delete<FILE, FileCloser>
70
// 或直接使用 unique_ptr<FILE, FileCloser> 并构造时传入 FILE*。
71
// 上面的例子使用了 unique_ptr<FILE, FileCloser> 和 unique_ptr<FILE, void(*)(FILE*)>
72
// 这两种写法是管理 FILE* 常见的 unique_ptr 类型声明方式。
73
74
return 0;
75
}
代码解析:
⚝ 我们定义了一个结构体 FileCloser，并在其中重载了函数调用运算符 operator()。这个函数对象接受一个 FILE* 指针作为参数，并在其中调用 fclose。这是一个“无状态”（stateless）的删除器，因为它不包含任何需要存储的状态。
⚝ 或者，我们也可以使用一个普通的函数 close_file_func 作为删除器。在这种情况下，unique_ptr 的模板类型需要显式指定删除器类型为函数指针 void(*)(FILE*)。
⚝ 在 main 函数中，我们在不同的作用域内创建 std::unique_ptr<FILE, FileCloser> 和 std::unique_ptr<FILE, void(*)(FILE*)> 对象。
⚝ 这些 unique_ptr 对象在构造时传入 fopen 返回的 FILE* 裸指针。注意，我们使用了直接构造的方式，因为 std::make_unique 不能用于带有定制删除器的场景（至少在 C++14 之前是如此，C++20 提供了 std::make_unique 的重载支持定制删除器）。
⚝ 当 unique_ptr 对象超出其作用域时，其析构函数被调用。析构函数会检查其管理的指针是否为空。如果不为空，它会调用绑定的定制删除器（FileCloser() 或 close_file_func）并传入管理的指针。
⚝ 定制删除器随后调用 fclose 关闭文件。整个过程是自动的，即使在 fopen 成功后但在文件使用过程中抛出异常，unique_ptr 的析构函数仍然会被调用，确保文件得到关闭。
定制删除器（Custom Deleter）的类型和大小影响:
定制删除器的类型会影响 unique_ptr 的完整类型和大小。
① 无状态删除器: 如果删除器是函数指针或一个不包含成员变量的函数对象类型（如上面的 FileCloser），它通常不会增加 unique_ptr 对象的大小，因为编译器可以通过空基类优化（Empty Base Optimization）存储删除器类型信息。unique_ptr 的大小通常和裸指针一样。
② 有状态删除器: 如果删除器是一个包含成员变量的函数对象，这些成员变量会成为 unique_ptr 对象的一部分，从而增加 unique_ptr 的大小。例如，一个删除器可能需要存储一个句柄或其他上下文信息。
理解这一点对于性能敏感的应用和内存布局有重要意义。对于大多数简单的定制删除场景（如关闭文件句柄、释放 C 风格分配的内存 free() 等），使用无状态的函数对象或函数指针即可，此时 unique_ptr 几乎没有额外开销。
8.3 多态对象的管理
在面向对象编程（Object-Oriented Programming, OOP）中，我们经常使用基类（base class）指针或引用来操作派生类（derived class）对象，实现多态性（polymorphism）。当这些多态对象是动态分配在堆上时，使用智能指针进行管理是最佳实践。std::unique_ptr 可以用来管理指向派生类对象的基类指针，但需要特别注意一个关键细节：基类必须有虚析构函数（virtual destructor）。
原因:
当通过基类指针删除一个派生类对象时，如果基类的析构函数不是虚函数，只会调用基类的析构函数，而不会调用派生类的析构函数。这会导致派生类中定义的资源（例如，派生类成员变量指向的堆内存）无法得到正确清理，从而造成资源泄漏。
std::unique_ptr<Base> 管理一个指向 Derived 对象的指针时，在其析构时会使用存储的删除器来释放资源。默认的删除器行为等同于 delete base_ptr;。为了确保在 delete base_ptr; 时能够正确调用派生类的析构函数，Base 类必须声明一个虚析构函数。
示例:
1
#include <iostream>
2
#include <memory>
3
#include <vector>
4
5
// 基类
6
class Base {
7
public:
8
Base() { std::cout << "Base::Base()\n"; }
9
// 关键：基类必须有虚析构函数
10
virtual ~Base() { std::cout << "Base::~Base()\n"; }
11
12
virtual void greet() const {
13
std::cout << "Hello from Base!\n";
14
}
15
};
16
17
// 派生类 1
18
class DerivedA : public Base {
19
public:
20
DerivedA() { std::cout << "DerivedA::DerivedA()\n"; }
21
~DerivedA() override { std::cout << "DerivedA::~DerivedA()\n"; } // override 关键字是好习惯
22
23
void greet() const override {
24
std::cout << "Hello from DerivedA!\n";
25
}
26
};
27
28
// 派生类 2
29
class DerivedB : public Base {
30
public:
31
DerivedB() { std::cout << "DerivedB::DerivedB()\n"; }
32
~DerivedB() override { std::cout << "DerivedB::~DerivedB()\n"; }
33
34
void greet() const override {
35
std::cout << "Hello from DerivedB!\n";
36
}
37
};
38
39
int main() {
40
// 使用 unique_ptr 管理多态对象
41
std::cout << "--- 管理单个多态对象 ---\n";
42
{ // 作用域开始
43
// unique_ptr<Base> 管理一个 DerivedA 对象
44
std::unique_ptr<Base> ptr_a = std::make_unique<DerivedA>(); // 使用 make_unique 更安全
45
46
ptr_a->greet(); // 调用 DerivedA 的 greet 方法（多态性）
47
48
// unique_ptr<Base> 管理一个 DerivedB 对象
49
std::unique_ptr<Base> ptr_b = std::make_unique<DerivedB>();
50
51
ptr_b->greet(); // 调用 DerivedB 的 greet 方法
52
} // ptr_a 和 ptr_b 在这里超出作用域并销毁
53
// unique_ptr<Base>::~unique_ptr() 会调用 delete ptr_a.get() 和 delete ptr_b.get()
54
// 由于 Base 的析构函数是虚函数，实际会调用 DerivedA::~DerivedA() 和 DerivedB::~DerivedB()
55
std::cout << "--- 单个多态对象作用域结束 ---\n";
56
57
std::cout << "\n--- 在容器中管理多态对象集合 ---\n";
58
{ // 另一个作用域
59
// 在容器中存储指向不同派生类对象的基类 unique_ptr
60
std::vector<std::unique_ptr<Base>> collection;
61
62
collection.push_back(std::make_unique<DerivedA>());
63
collection.push_back(std::make_unique<DerivedB>());
64
collection.push_back(std::make_unique<DerivedA>());
65
66
// 遍历容器，通过基类指针调用多态方法
67
for (const auto& ptr : collection) {
68
ptr->greet();
69
}
70
71
// 当 collection 超出作用域时，vector 中的每个 unique_ptr 会被销毁
72
// 每个 unique_ptr 都会正确地通过虚析构函数销毁其指向的派生类对象
73
} // collection 在这里超出作用域并销毁
74
std::cout << "--- 容器管理多态对象作用域结束 ---\n";
75
76
// 如果 Base 没有虚析构函数，DerivedA 和 DerivedB 的析构函数将不会被调用！
77
78
return 0;
79
}
代码解析:
⚝ Base 类声明了一个 virtual ~Base() 虚析构函数。这是正确管理多态对象生命周期的关键。
⚝ DerivedA 和 DerivedB 继承自 Base，并提供了自己的析构函数（使用了 override 关键字，这是一个很好的实践，表明函数意图覆盖基类的虚函数）。
⚝ 在 main 函数中，我们创建了 std::unique_ptr<Base> 对象，但它们实际指向的是 DerivedA 和 DerivedB 的实例。
⚝ 通过 ptr->greet() 调用展示了多态性，实际执行的是派生类的 greet 方法。
⚝ 当 unique_ptr 对象超出作用域时，它们的析构函数被调用。例如，对于 ptr_a (unique_ptr<Base> 指向 DerivedA)，unique_ptr 的析构会执行类似 delete ptr_a.get(); 的操作。因为 Base::~Base 是虚函数，这个 delete 操作会正确地通过虚函数表调用 DerivedA::~DerivedA()，然后再调用 Base::~Base()，确保了完整的清理过程。
⚝ 将 unique_ptr<Base> 存储在 std::vector 中也是一个常见的模式，用于管理一个异构（多态）对象的集合。当 vector 被销毁时，它会销毁其包含的所有 unique_ptr，从而触发所有被管理对象的正确销毁。
总结:
使用 std::unique_ptr<Base> 管理派生类对象是安全和高效的，但前提是基类必须拥有一个虚析构函数。如果基类没有虚析构函数，且通过基类指针删除派生类对象，将导致未定义行为（undefined behavior），通常表现为派生类部分的资源泄漏。这是使用多态和动态内存管理时必须牢记的原则。
8.4 模块或插件系统的接口
在设计大型软件系统或可扩展的模块/插件架构时，经常需要在某个模块内部创建对象，然后将该对象的控制权（所有权）转移给调用方或另一个模块。std::unique_ptr 的所有权转移语义（通过移动语义实现）非常适合这种场景。
考虑一个简单的工厂函数（factory function），它负责创建某个接口（基类）的具体实现（派生类）对象。将工厂函数的返回值类型设计为 std::unique_ptr<Interface> 是一种非常安全且符合现代 C++ 实践的方式。
示例:
假设我们有一个图形绘制模块，定义了一个 Shape 接口。不同的形状（如 Circle, Square）是这个接口的具体实现。我们希望通过一个工厂来创建这些形状对象。
1
#include <iostream>
2
#include <memory> // For std::unique_ptr
3
#include <string>
4
#include <stdexcept> // For std::runtime_error
5
6
// 基类/接口
7
class Shape {
8
public:
9
Shape() { std::cout << "Shape::Shape()\n"; }
10
virtual ~Shape() { std::cout << "Shape::~Shape()\n"; } // 基类需要虚析构函数
11
12
virtual void draw() const = 0; // 纯虚函数，接口
13
};
14
15
// 派生类 1
16
class Circle : public Shape {
17
public:
18
Circle() { std::cout << "Circle::Circle()\n"; }
19
~Circle() override { std::cout << "Circle::~Circle()\n"; }
20
void draw() const override {
21
std::cout << "Drawing a Circle.\n";
22
}
23
};
24
25
// 派生类 2
26
class Square : public Shape {
27
public:
28
Square() { std::cout << "Square::Square()\n"; }
29
~Square() override { std::cout << "Square::~Square()\n"; }
30
void draw() const override {
31
std::cout << "Drawing a Square.\n";
32
}
33
};
34
35
// 工厂函数：根据类型字符串创建 Shape 对象
36
// 返回 unique_ptr 转移新创建对象的所有权
37
std::unique_ptr<Shape> createShape(const std::string& type) {
38
if (type == "circle") {
39
// 在工厂内部创建对象
40
auto circle = std::make_unique<Circle>();
41
// 返回 unique_ptr，所有权从函数内部转移到调用方
42
return circle; // C++11 起，对于纯右值或将要过期的左值，编译器会自动执行移动 (返回值优化或强制移动)
43
// 等价于 return std::move(circle); 但通常不需要显式写 std::move
44
} else if (type == "square") {
45
return std::make_unique<Square>(); // 推荐的简洁写法
46
} else {
47
// 创建失败，返回空的 unique_ptr 或抛出异常
48
std::cerr << "未知形状类型: " << type << std::endl;
49
// return nullptr; // 返回空指针表示失败
50
throw std::runtime_error("Unknown shape type"); // 抛出异常是另一种处理错误的方式
51
}
52
}
53
54
int main() {
55
std::cout << "--- 使用工厂函数创建对象 ---\n";
56
try {
57
// 调用工厂函数，接收 unique_ptr 返回值
58
// unique_ptr<Shape> shape1 = createShape("circle"); // 隐式移动
59
auto shape1 = createShape("circle"); // 使用 auto 更简洁
60
61
if (shape1) {
62
shape1->draw();
63
}
64
65
auto shape2 = createShape("square");
66
if (shape2) {
67
shape2->draw();
68
}
69
70
// 尝试创建未知类型，会抛出异常
71
// auto shape3 = createShape("triangle");
72
// if (shape3) {
73
// shape3->draw();
74
// }
75
76
} catch (const std::runtime_error& e) {
77
std::cerr << "创建形状失败: " << e.what() << std::endl;
78
}
79
80
std::cout << "\n--- 将创建的对象放入容器 ---\n";
81
std::vector<std::unique_ptr<Shape>> drawing_list;
82
83
drawing_list.push_back(createShape("circle")); // createShape 返回的 unique_ptr 被移动到 vector 中
84
drawing_list.push_back(createShape("square"));
85
drawing_list.push_back(createShape("circle"));
86
87
std::cout << "绘制列表中的形状:\n";
88
for (const auto& shape_ptr : drawing_list) {
89
if (shape_ptr) {
90
shape_ptr->draw();
91
}
92
}
93
94
// 当 main 函数结束时，drawing_list 超出作用域，销毁其所有 unique_ptr 成员
95
// 每个 unique_ptr 会通过 Shape 的虚析构函数正确销毁其指向的派生类对象
96
std::cout << "--- 程序结束，对象自动清理 ---\n";
97
98
return 0;
99
}
代码解析:
⚝ Shape 类作为接口，定义了虚析构函数和纯虚函数 draw()。
⚝ Circle 和 Square 是具体的形状实现类，继承自 Shape 并实现 draw() 方法，同样拥有虚析构函数。
⚝ createShape 函数是工厂，其返回值类型是 std::unique_ptr<Shape>。这意味着函数承诺返回一个新创建的 Shape（或其派生类）对象的独占所有权。
⚝ 在 createShape 函数内部，使用 std::make_unique 创建具体的派生类对象。
⚝ 通过 return circle; (或 return std::make_unique<Square>();) 返回 unique_ptr 时，C++ 的返回值优化（Return Value Optimization, RVO）或命名返回值优化（Named Return Value Optimization, NRVO）会在可能的情况下避免拷贝。即使不能避免，unique_ptr 具有移动构造函数，会执行移动语义，将所有权高效地转移给函数调用方，而不会发生拷贝。
⚝ 调用方（如 main 函数）接收 createShape 返回的 unique_ptr，从而获得了新创建对象的所有权。
⚝ 调用方现在负责管理这个对象的生命周期。当接收返回值的 unique_ptr（如 shape1, shape2）超出作用域时，它们会自动销毁所管理的 Shape 对象，通过虚析构函数确保正确清理。
⚝ 将从工厂获得的 unique_ptr 放入 std::vector<std::unique_ptr<Shape>> 中也是非常自然的。vector 将负责管理这些对象的集合生命周期。
使用 unique_ptr 作为工厂函数返回值的好处:
① 清晰的所有权转移: 明确表达了工厂函数将新创建对象的独占所有权转移给调用方，避免了裸指针返回可能导致的所有权模糊问题。
② 内存安全: 保证了返回的对象会被其新的所有者 (unique_ptr) 安全地管理和自动释放，防止了内存泄漏。
③ 异常安全: 如果工厂函数内部发生异常，已由 unique_ptr 管理的资源会得到清理。如果工厂函数在返回前抛出异常，也没有已转移所有权的资源需要调用方手动清理。
④ 支持多态: 返回 unique_ptr<Base> 可以方便地管理不同的派生类对象。
⑤ 高效: 移动语义确保所有权转移的开销很低。
这种模式是现代 C++ 中实现工厂、插件加载或需要跨越模块边界转移资源所有权的标准且推荐方式。
9. unique_ptr 在 C++ 标准中的演进
unique_ptr 作为现代 C++ 内存管理的重要工具，并非凭空出现，而是 C++ 标准委员会在吸取了早期经验、拥抱新语言特性后，精心设计并引入的。本章将回顾 unique_ptr 从 C++11 诞生至今在标准中的发展历程，探讨其被引入的背景、解决的问题，以及后续标准对其功能和易用性带来的重要改进。了解其演进过程，有助于我们更深刻地理解 unique_ptr 的设计哲学和应用场景。
9.1 C++11：unique_ptr 的诞生
在 C++11 之前，手动进行动态内存管理（使用 new 和 delete）是常见的做法，但这带来了前一章提到的诸多问题：内存泄漏（memory leak）、重复释放（double free）、野指针（dangling pointer）等。虽然有一些库提供了智能指针的实现（如 Boost 库），但标准库中唯一一个尝试提供自动内存管理的智能指针是 C++98 中的 std::auto_ptr。
std::auto_ptr 试图实现独占所有权（exclusive ownership）语义，即一个 auto_ptr 对象拥有其指向的资源，当 auto_ptr 被销毁时，它会自动释放资源。然而，auto_ptr 的设计存在一个致命缺陷：它的拷贝构造函数（copy constructor）和拷贝赋值运算符（copy assignment operator）实际上执行的是所有权转移（transfer of ownership），而非传统的拷贝。这意味着，拷贝一个 auto_ptr 会使其源对象变为空（null）。这种非标准的拷贝语义极易引发意料之外的行为和错误，尤其是在使用标准容器或作为函数参数传递时。例如：
1
std::auto_ptr<int> p1(new int(10));
2
std::auto_ptr<int> p2 = p1; // 所有权从 p1 转移到 p2
3
// 此时 p1 变为空指针，访问 p1 将导致未定义行为！
4
// int value = *p1; // 错误！
为了解决 auto_ptr 的问题，并在标准库中提供一个安全、高效的独占所有权智能指针，C++11 引入了 std::unique_ptr。
std::unique_ptr 在 C++11 中的主要特性：
① 独占所有权（exclusive ownership）：unique_ptr 严格保证任何时刻只有一个 unique_ptr 对象拥有其指向的资源。
② 不可拷贝性（Non-copyable）：为了强制执行独占所有权，unique_ptr 的拷贝构造函数和拷贝赋值运算符被明确删除（deleted）。这使得尝试拷贝 unique_ptr 在编译时就会报错，避免了 auto_ptr 的运行时陷阱。
③ 支持移动语义（Move Semantics）：C++11 引入了右值引用（rvalue reference）和移动语义。unique_ptr 利用这一特性，提供了移动构造函数（move constructor）和移动赋值运算符（move assignment operator）。这允许安全地将资源的所有权从一个 unique_ptr 转移到另一个，而源对象在转移后变为空。这是 unique_ptr 传递和返回的主要方式。
④ 低开销（Low Overhead）：unique_ptr 的设计目标之一是接近于裸指针（raw pointer）的性能。在大多数情况下，unique_ptr 在运行时没有额外的开销（如引用计数），其大小通常与裸指针或裸指针加上一个删除器（deleter）的大小相同。
⑤ 支持定制删除器（Custom Deleter）：unique_ptr 支持通过模板参数指定一个删除器，用于释放非内存资源（如文件句柄、网络连接）或使用特定的内存释放方式。
⑥ 支持数组类型：unique_ptr 有一个特化版本 unique_ptr<T[]>，可以正确管理动态分配的数组，并在销毁时使用 delete[] 进行释放。
C++11 引入的 unique_ptr 配合移动语义，提供了一种安全且高效的方式来管理动态分配的单个对象或数组，极大地提高了 C++ 代码的健壮性，并替代了 auto_ptr。
9.2 C++14：std::make_unique 的加入
尽管 unique_ptr 在 C++11 中已经是一个非常强大的工具，但其构造方式有时略显繁琐。通常，我们需要这样创建 unique_ptr：
1
std::unique_ptr<MyObject> ptr(new MyObject(arg1, arg2));
这种方式有几个潜在的问题：
① 不够简洁：需要重复类型名称，并且 new 和 unique_ptr 的构造是两个独立的步骤。
② 异常安全性问题：考虑表达式 foo(std::unique_ptr<X>(new X()), create_y())。如果 create_y() 抛出异常，在 new X() 分配内存之后但在 std::unique_ptr<X> 构造完成之前，分配的 X 对象可能得不到管理，从而导致内存泄漏。这是因为 C++ 标准不保证表达式的求值顺序，new X()、std::unique_ptr<X> 的构造函数以及 create_y() 的调用可能以交错的方式进行。
为了解决这些问题，C++14 标准库引入了 std::make_unique 函数模板。使用 std::make_unique 创建 unique_ptr 变得更加简洁和安全：
1
auto ptr = std::make_unique<MyObject>(arg1, arg2);
使用 std::make_unique 的好处：
① 语法简洁：无需重复类型名称，可以使用 auto 关键字简化声明。
② 异常安全（Exception Safety）：std::make_unique 将对象的创建（new）和 unique_ptr 的构造封装在单个函数调用中。C++ 标准保证函数参数的求值顺序，或者至少保证 std::make_unique 内部的 new 操作和 unique_ptr 构造是原子性的（在一个表达式内完成），从而避免了上述中间状态可能导致的内存泄漏。
③ 性能优化（可能）：在某些情况下，make_unique 可以允许编译器进行优化，例如减少一次内存分配（对于非数组类型），虽然这点在 unique_ptr 中不像在 shared_ptr (通过 make_shared) 中那么突出，但其主要的优势在于异常安全性和代码简洁性。
std::make_unique 的引入，使得 unique_ptr 的使用更加方便和安全，成为创建 unique_ptr 的首选方式（除非你需要使用定制删除器或从现有裸指针接管所有权）。
9.3 后续标准中的相关改进
自 C++14 引入 std::make_unique 之后，C++ 标准在 unique_ptr 本身的核心功能上没有再做根本性的改变，因为它已经是一个设计精良、功能完备的独占所有权智能指针。然而，后续的标准（如 C++17, C++20, C++23 等）通过引入其他特性，间接增强了 unique_ptr 的易用性或与其他语言特性的协同能力。
这些改进主要体现在：
① 类模板参数推导 (Class Template Argument Deduction - CTAD) (C++17): 虽然 std::make_unique 已经提供了便利的 auto 声明，但对于直接构造 unique_ptr（例如，使用定制删除器时），C++17 的类模板参数推导可以进一步简化语法。例如：
1
// C++11/14
2
std::unique_ptr<MyObject, CustomDeleter> ptr1(new MyObject, CustomDeleter());
3
4
// C++17 using CTAD
5
std::unique_ptr ptr2(new MyObject, CustomDeleter()); // 编译器可以推导出类型 MyObject 和 CustomDeleter
这使得在不使用 make_unique 的场景下，构造 unique_ptr 也更加简洁。
② 协程 (Coroutines) (C++20): C++20 引入了协程。在协程的实现和使用中，资源管理是一个重要的方面。虽然 unique_ptr 不是协程特有的机制，但它作为现代 C++ 资源管理工具，在协程中管理动态分配的状态对象或资源时，依然发挥着关键作用，保证了协程在暂停和恢复过程中的资源安全。
③ Ranges 库 (C++20): Ranges 库提供了一种更现代、函数式的方式处理序列数据。虽然 unique_ptr 本身不直接参与 Ranges 的操作，但当 Range 中的元素是 unique_ptr 或需要动态分配资源时，unique_ptr 仍然是管理这些元素生命周期的标准工具。例如，一个 Range 可能产生 unique_ptr 序列，后续操作可以通过移动语义处理这些 unique_ptr。
④ 其他语言和库特性的演进: 随着整个 C++ 生态系统的发展，如模块 (Modules)、概念 (Concepts) 等新特性，虽然它们不直接修改 unique_ptr 的行为，但会影响到如何组织、编译和使用包含 unique_ptr 的代码。例如，概念可以用来更好地约束模板参数（尽管 unique_ptr 本身不太需要），模块可以改善包含智能指针类型定义的头文件管理。
总的来说，unique_ptr 的核心功能和设计在 C++11 中已经非常成熟。后续的标准更多是在语言层面和库层面提供了补充和便利，使得 unique_ptr 作为独占所有权智能指针，在更广阔的现代 C++ 编程环境中能够更好地集成和使用。它的简洁、高效和安全性，使其成为了管理独占资源的首选方案，并且这一地位在未来的 C++ 标准中也将继续保持。
Appendix A: 术语表 (Glossary)
本附录提供了本书中使用的关键术语及其简要解释，旨在帮助读者更好地理解核心概念。
⚝ C++: 一种通用、静态类型、自由形式、多范式（支持过程化编程、数据抽象、面向对象编程、泛型编程）的编程语言。本书主要讨论 C++11 及后续标准（如 C++14, C++17）中引入的特性。
⚝ 智能指针 (Smart Pointer): C++ 中用于管理动态分配内存或其他资源的类模板。它们模仿裸指针的行为，但在指针超出作用域或不再使用时能自动释放所管理的资源，从而避免内存泄漏等问题。
⚝ unique_ptr: C++11 标准库中引入的一种智能指针，实现独占所有权 (exclusive ownership) 语义。同一时刻只有一个 unique_ptr 可以指向特定的资源。当 unique_ptr 被销毁时，它所管理的资源也会被自动释放。
⚝ 内存管理 (Memory Management): 在程序执行过程中，对计算机内存资源的分配、使用和释放过程。在 C++ 中，手动内存管理（使用 new 和 delete）容易出错，智能指针提供了一种自动化的管理方式。
⚝ RAII (Resource Acquisition Is Initialization): 资源获取即初始化。这是一种 C++ 编程习惯，将资源的生命周期与对象的生命周期绑定。在对象构造时获取资源，在对象析构时释放资源。智能指针是 RAII 原则在内存管理中的典型应用。
⚝ 所有权语义 (Ownership Semantics): 指针或智能指针对其所指向资源的管理职责模型。unique_ptr 实现独占所有权，而 shared_ptr 实现共享所有权 (shared ownership)。
⚝ 裸指针 (Raw Pointer): 指 C++ 中传统的指针类型（如 int*, char*）。使用裸指针进行动态内存管理时，需要程序员手动调用 delete 或 delete[] 释放内存，容易出错。
⚝ 内存泄漏 (Memory Leak): 程序分配了内存，但未能通过适当的方式释放，导致这部分内存无法被回收，长时间运行可能耗尽系统内存资源。
⚝ 重复释放 (Double Free): 对同一块动态分配的内存调用了多次释放操作（如 delete 或 delete[]），这是一种未定义行为，通常会导致程序崩溃。
⚝ 野指针 (Dangling Pointer): 指向已经被释放内存区域的指针。如果程序试图通过野指针访问内存，也会导致未定义行为。
⚝ 移动语义 (Move Semantics): C++11 引入的一种机制，允许资源（如动态内存）的所有权从一个对象转移到另一个对象，而不是进行昂贵的拷贝操作。这通过右值引用 (rvalue reference) 和移动构造函数 (move constructor)/移动赋值运算符 (move assignment operator) 实现。
⚝ std::move: C++ 标准库中的函数模板，用于将左值强制转换为右值引用。它本身不执行任何移动操作，只是表明该对象可以被“移动”，即其资源可以被转移。
⚝ std::make_unique: C++14 标准库中引入的函数模板，用于构造 unique_ptr 并管理新创建的对象。它通常比直接使用 new 创建 unique_ptr 更安全、更简洁。
⚝ 定制删除器 (Custom Deleter): 为智能指针指定的非默认的资源释放方式。对于 unique_ptr，可以通过模板参数或构造函数指定一个函数指针、函数对象或 Lambda 表达式作为删除器，用于管理文件句柄、网络连接等非内存资源或实现特殊的清理逻辑。
⚝ 函数指针 (Function Pointer): 指向函数的指针变量。可以作为 unique_ptr 的定制删除器类型。
⚝ 函数对象 (Functor): 重载了函数调用运算符 operator() 的类或结构体对象。函数对象可以存储状态，比函数指针更灵活，也可以作为 unique_ptr 的定制删除器。
⚝ Lambda 表达式 (Lambda Expression): C++11 引入的一种匿名函数。它们可以捕获周围作用域的变量，常用于定义简单的函数对象，是定制删除器的常用方式。
⚝ Pimpl 模式 (Pointer to Implementation Pattern): 一种软件设计模式，将类的实现细节隐藏在一个私有的指针后面。这个指针通常指向一个包含所有私有成员和实现细节的结构体或类。使用 unique_ptr 管理这个指针可以实现自动化的内存管理和异常安全。
⚝ 异常安全 (Exception Safety): 指程序在发生异常时仍能保持某种程度的正确状态。强异常安全保证操作要么完全成功，要么完全不改变程序状态。unique_ptr 的 RAII 特性天然有助于实现异常安全。
⚝ shared_ptr: C++11 标准库中的另一种智能指针，实现共享所有权 (shared ownership) 语义。多个 shared_ptr 可以共同管理同一个资源，通过内部的引用计数 (reference counting) 机制追踪资源的引用数量。当最后一个 shared_ptr 被销毁时，资源才会被释放。
⚝ weak_ptr: C++11 标准库中的智能指针，与 shared_ptr 配合使用。它不拥有资源的所有权，也不会增加资源的引用计数。主要用于打破 shared_ptr 之间的循环引用，或者安全地观察 shared_ptr 管理的资源是否存在。
⚝ 引用计数 (Reference Counting): 一种跟踪共享资源被引用次数的机制。shared_ptr 使用引用计数来决定何时释放资源。
⚝ 非内存资源 (Non-memory Resources): 指除了通过 new 分配的堆内存之外的需要管理的资源，例如文件句柄、网络套接字、互斥锁、数据库连接等。unique_ptr 可以通过定制删除器管理这类资源。
⚝ 资源管理 (Resource Management): 程序中获取、使用和释放各种资源（包括内存、文件、锁等）的过程。高效和安全的资源管理是编写健壮程序的基础。
⚝ 现代C++ (Modern C++): 通常指 C++11 及其后续标准（C++14, C++17, C++20 等）所提倡和支持的编程风格和特性，包括智能指针、移动语义、Lambda 表达式、范围 for 循环等。
⚝ 不可拷贝性 (Non-copyable): 指一个类的对象不能通过拷贝构造函数或拷贝赋值运算符创建副本。unique_ptr 是不可拷贝的，以保证其独占所有权语义。
⚝ get(): unique_ptr 的成员函数，返回其内部存储的裸指针。使用时需谨慎，因为获取到裸指针后，程序员需要自行确保其生命周期管理，不能在其生命周期结束后继续使用。
⚝ release(): unique_ptr 的成员函数，释放其对所管理资源的所有权，并返回其内部存储的裸指针，同时将 unique_ptr 置为空。调用 release() 后，原先由 unique_ptr 管理的资源将不再被智能指针自动释放，需要程序员手动处理。
⚝ reset(): unique_ptr 的成员函数，用于释放当前管理的资源（如果存在），并可以选择管理一个新的资源。调用 ptr.reset(new_ptr) 会先释放 ptr 当前管理的资源，然后让 ptr 管理 new_ptr 指向的资源。调用 ptr.reset() 会释放当前资源并将 ptr 置为空。
⚝ delete: C++ 中用于释放通过 new 分配的单个对象的内存。
⚝ delete[]: C++ 中用于释放通过 new[] 分配的数组的内存。unique_ptr<T[]> 使用 delete[] 作为其默认删除器。
Appendix B: unique_ptr 关键函数/方法速查
Appendix B1: 概述
本附录旨在为读者提供 std::unique_ptr 的关键成员函数 (member function) 和非成员函数 (non-member function) 的速查。这些函数构成了 unique_ptr 的核心接口 (interface)，理解它们对于高效、安全地使用 unique_ptr 至关重要。本速查将列出常用函数的声明 (declaration) 或签名 (signature)，并提供简要的功能描述。更详细的用法和示例请参考本书正文相关章节。
Appendix B2: 成员函数速查
本节列出 std::unique_ptr 的主要成员函数。
① 构造函数 (Constructors)
▮▮▮▮⚝ 默认构造函数 (Default Constructor): unique_ptr() noexcept;
▮▮▮▮▮▮▮▮⚝ 创建一个空的 unique_ptr，不管理任何资源。
▮▮▮▮⚝ nullptr 构造函数: unique_ptr(nullptr_t) noexcept;
▮▮▮▮▮▮▮▮⚝ 创建一个空的 unique_ptr。与默认构造函数效果相同。
▮▮▮▮⚝ 裸指针构造函数 (Raw Pointer Constructor): explicit unique_ptr(pointer p) noexcept;
▮▮▮▮▮▮▮▮⚝ 从一个裸指针 p 构造 unique_ptr，接管 p 指向资源的所有权 (ownership)。要求 p 是由 new 分配的，或者其类型与删除器 (deleter) 兼容。
▮▮▮▮▮▮▮▮⚝ 注意：此构造函数是 explicit 的，防止隐式转换。
▮▮▮▮⚝ 移动构造函数 (Move Constructor): unique_ptr(unique_ptr&& u) noexcept;
▮▮▮▮▮▮▮▮⚝ 从另一个 unique_ptr u 移动所有权。移动后，u 变为空。这是 unique_ptr 实现独占所有权语义 (exclusive ownership semantics) 的关键。
▮▮▮▮⚝ 带删除器的构造函数: 允许指定一个定制删除器。
▮▮▮▮▮▮▮▮⚝ unique_ptr(pointer p, const Deleter& d) noexcept;
▮▮▮▮▮▮▮▮⚝ unique_ptr(pointer p, Deleter&& d) noexcept;
▮▮▮▮▮▮▮▮⚝ 从裸指针 p 和定制删除器 d 构造 unique_ptr。
② 析构函数 (Destructor): ~unique_ptr();
▮▮▮▮⚝ 当 unique_ptr 对象超出作用域 (scope) 或被显式销毁时调用。
▮▮▮▮⚝ 如果 unique_ptr 管理着一个资源（即不为空），它将使用其关联的删除器释放该资源。默认删除器对单个对象调用 delete，对数组调用 delete[]。
③ 赋值运算符 (Assignment Operators)
▮▮▮▮⚝ 移动赋值运算符 (Move Assignment Operator): unique_ptr& operator=(unique_ptr&& u) noexcept;
▮▮▮▮▮▮▮▮⚝ 释放当前 unique_ptr 管理的资源（如果存在），然后从 u 转移所有权。转移后，u 变为空。
▮▮▮▮⚝ nullptr 赋值运算符: unique_ptr& operator=(nullptr_t) noexcept;
▮▮▮▮▮▮▮▮⚝ 释放当前 unique_ptr 管理的资源（如果存在），然后将 unique_ptr 置为空。
④ 资源访问 (Resource Access)
▮▮▮▮⚝ 解引用运算符 (Dereference Operator): T& operator*() const; (对于 unique_ptr<T>)
▮▮▮▮▮▮▮▮⚝ 返回对所管理对象的引用。前置条件: unique_ptr 必须不为空。
▮▮▮▮⚝ 成员访问运算符 (Member Access Operator): T* operator->() const noexcept; (对于 unique_ptr<T>)
▮▮▮▮▮▮▮▮⚝ 返回所管理对象的指针，并允许通过 -> 访问其成员。前置条件: unique_ptr 必须不为空。
▮▮▮▮⚝ 获取裸指针 (Get Raw Pointer): pointer get() const noexcept;
▮▮▮▮▮▮▮▮⚝ 返回所管理资源的裸指针。注意: 不要使用返回的裸指针来释放资源，所有权仍在 unique_ptr 手中。小心使用 get() 返回的指针，避免出现野指针 (dangling pointer)。
1
#include <iostream>
2
#include <memory>
3
4
int main() {
5
auto ptr = std::make_unique<int>(10);
6
int* raw_ptr = ptr.get(); // 获取裸指针
7
8
std::cout << "Value via unique_ptr: " << *ptr << std::endl;
9
std::cout << "Value via raw pointer: " << *raw_ptr << std::endl;
10
11
// 不要在 unique_ptr 仍然管理资源时 delete raw_ptr!
12
// delete raw_ptr; // 错误！会导致双重释放 (double free)
13
return 0;
14
}
⑤ 所有权操作 (Ownership Operations)
▮▮▮▮⚝ 释放所有权 (Release Ownership): pointer release() noexcept;
▮▮▮▮▮▮▮▮⚝ 放弃对所管理资源的所有权，并返回指向该资源的裸指针。unique_ptr 变为空，不再负责资源的释放。调用者现在有责任管理返回的裸指针。
1
#include <iostream>
2
#include <memory>
3
4
int main() {
5
auto ptr = std::make_unique<int>(20);
6
int* raw_ptr = ptr.release(); // 释放所有权，ptr 变为空
7
8
std::cout << "ptr is now " << (ptr ? "not null" : "null") << std::endl;
9
std::cout << "Released value: " << *raw_ptr << std::endl;
10
11
delete raw_ptr; // 现在由我们手动释放资源
12
return 0;
13
}
▮▮▮▮⚝ 替换或释放资源 (Replace or Release Resource): void reset(pointer p = pointer()) noexcept;
▮▮▮▮▮▮▮▮⚝ 释放当前 unique_ptr 管理的资源（如果存在），然后接管参数 p 指向资源的所有权。如果 p 为空指针，则 unique_ptr 变为空。
1
#include <iostream>
2
#include <memory>
3
4
int main() {
5
auto ptr = std::make_unique<int>(30);
6
std::cout << "Original value: " << *ptr << std::endl;
7
8
ptr.reset(new int(40)); // 释放旧资源，管理新资源
9
std::cout << "New value after reset: " << *ptr << std::endl;
10
11
ptr.reset(); // 释放当前资源，ptr 变为空
12
std::cout << "ptr is now " << (ptr ? "not null" : "null") << std::endl;
13
14
return 0;
15
}
▮▮▮▮⚝ 交换所有权 (Swap Ownership): void swap(unique_ptr& u) noexcept;
▮▮▮▮▮▮▮▮⚝ 交换当前 unique_ptr 和另一个 unique_ptr u 所管理资源的所有权。
1
#include <iostream>
2
#include <memory>
3
#include <utility> // for std::swap
4
5
int main() {
6
auto ptr1 = std::make_unique<int>(50);
7
auto ptr2 = std::make_unique<int>(60);
8
9
std::cout << "Before swap: *ptr1 = " << *ptr1 << ", *ptr2 = " << *ptr2 << std::endl;
10
11
ptr1.swap(*ptr2); // 使用成员函数 swap
12
// 或者 std::swap(ptr1, ptr2); // 使用非成员函数 std::swap
13
14
std::cout << "After swap: *ptr1 = " << *ptr1 << ", *ptr2 = " << *ptr2 << std::endl;
15
16
return 0;
17
}
⑥ 状态检查 (State Check)
▮▮▮▮⚝ 布尔转换运算符 (Boolean Conversion Operator): explicit operator bool() const noexcept;
▮▮▮▮▮▮▮▮⚝ 允许将 unique_ptr 对象隐式转换为 bool 类型。如果 unique_ptr 管理着资源（即不为空），则转换为 true；否则转换为 false。常用于条件判断。
1
#include <iostream>
2
#include <memory>
3
4
int main() {
5
auto ptr1 = std::make_unique<int>(70);
6
std::unique_ptr<int> ptr2; // 默认构造，为空
7
8
if (ptr1) {
9
std::cout << "ptr1 is not null." << std::endl;
10
}
11
12
if (!ptr2) {
13
std::cout << "ptr2 is null." << std::endl;
14
}
15
16
return 0;
17
}
⑦ 数组特化成员 (Array Specialization Members)
▮▮▮▮⚝ 数组元素访问运算符 (Array Element Access Operator): T& operator[](size_t i) const; (对于 unique_ptr<T[]>)
▮▮▮▮▮▮▮▮⚝ 允许像访问数组一样访问 unique_ptr<T[]> 所管理内存中的元素。
1
#include <iostream>
2
#include <memory>
3
4
int main() {
5
auto arr_ptr = std::make_unique<int[]>(5);
6
for (int i = 0; i < 5; ++i) {
7
arr_ptr[i] = (i + 1) * 10;
8
}
9
10
std::cout << "Elements: ";
11
for (int i = 0; i < 5; ++i) {
12
std::cout << arr_ptr[i] << (i == 4 ? "" : ", ");
13
}
14
std::cout << std::endl;
15
16
return 0;
17
}
Appendix B3: 非成员函数速查
本节列出与 std::unique_ptr 相关的常用非成员函数。
① 创建函数
▮▮▮▮⚝ std::make_unique (C++14)
▮▮▮▮▮▮▮▮⚝ template<class T, class... Args> unique_ptr<T> make_unique(Args&&... args); (创建单个对象)
▮▮▮▮▮▮▮▮⚝ template<class T> unique_ptr<T> make_unique(size_t n); (创建数组)
▮▮▮▮▮▮▮▮⚝ 用于创建 unique_ptr 并管理一个新分配的对象或数组。强烈推荐使用 make_unique 而非直接使用 new，因为它提供了异常安全保证并使代码更简洁。
1
#include <iostream>
2
#include <memory>
3
4
int main() {
5
// 创建单个对象
6
auto obj_ptr = std::make_unique<int>(100);
7
std::cout << "Object value: " << *obj_ptr << std::endl;
8
9
// 创建数组
10
auto arr_ptr = std::make_unique<double[]>(3);
11
arr_ptr[0] = 1.1;
12
arr_ptr[1] = 2.2;
13
arr_ptr[2] = 3.3;
14
std::cout << "Array elements: " << arr_ptr[0] << ", " << arr_ptr[1] << ", " << arr_ptr[2] << std::endl;
15
16
return 0;
17
}
② 交换函数
▮▮▮▮⚝ std::swap
▮▮▮▮▮▮▮▮⚝ template<class T, class D> void swap(unique_ptr<T, D>& x, unique_ptr<T, D>& y) noexcept;
▮▮▮▮▮▮▮▮⚝ 非成员版本的 swap，调用两个 unique_ptr 对象的成员 swap 函数来交换它们管理的所有权。这是在泛型编程 (generic programming) 中优先使用的 swap 形式。
③ 比较运算符 (Comparison Operators)
▮▮▮▮⚝ 提供了基于所管理裸指针的比较运算符。
▮▮▮▮▮▮▮▮⚝ template<class T1, class D1, class T2, class D2> bool operator==(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
▮▮▮▮▮▮▮▮⚝ template<class T1, class D1, class T2, class D2> bool operator!=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
▮▮▮▮▮▮▮▮⚝ template<class T1, class D1, class T2, class D2> bool operator<(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
▮▮▮▮▮▮▮▮⚝ template<class T1, class D1, class T2, class D2> bool operator<=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
▮▮▮▮▮▮▮▮⚝ template<class T1, class D1, class T2, class D2> bool operator>(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
▮▮▮▮▮▮▮▮⚝ template<class T1, class D1, class T2, class D2> bool operator>=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
▮▮▮▮▮▮▮▮⚝ 这些运算符比较的是两个 unique_ptr 内部存储的裸指针的值。它们也支持与 nullptr_t 进行比较，例如 ptr == nullptr 或 ptr != nullptr，这等价于 !ptr 或 !!ptr。
1
#include <iostream>
2
#include <memory>
3
4
int main() {
5
auto ptr1 = std::make_unique<int>(10);
6
auto ptr2 = std::make_unique<int>(20);
7
std::unique_ptr<int> ptr3; // null
8
9
if (ptr1 == ptr2) {
10
std::cout << "ptr1 and ptr2 point to the same address (unlikely)." << std::endl;
11
} else {
12
std::cout << "ptr1 and ptr2 point to different addresses." << std::endl;
13
}
14
15
if (ptr3 == nullptr) {
16
std::cout << "ptr3 is null." << std::endl;
17
}
18
19
return 0;
20
}
这些函数和方法构成了 std::unique_ptr 功能的基础。熟练掌握它们的使用，是写出安全、高效的现代 C++ 代码的关键。
Appendix C: 常见问题解答 (FAQ)
Appendix C1: unique_ptr 与裸指针 (raw pointer) 相比有什么优势？
👍 回答: std::unique_ptr 是 C++11 引入的一种智能指针 (smart pointer)，它与传统的裸指针 (raw pointer) 相比，主要优势在于自动化的资源管理和更高的安全性。
① 自动化的内存管理 (Automated Memory Management):
▮▮▮▮⚝ 裸指针需要开发者手动调用 delete 来释放通过 new 分配的内存。这极易导致内存泄漏 (memory leak)——如果在 delete 调用之前程序流程异常退出（例如抛出异常）或者忘记调用 delete，内存将永远不会被释放。
▮▮▮▮⚝ unique_ptr 利用 RAII (Resource Acquisition Is Initialization) 原则。它在其生命周期结束时（例如，当它超出作用域或者 unique_ptr 对象本身被销毁时），会自动调用其默认的删除器（通常是 delete）来释放所管理的资源。这极大地减少了内存泄漏的风险。
② 异常安全 (Exception Safety):
▮▮▮▮⚝ 在使用裸指针时，如果在资源分配和释放之间发生了异常，释放资源的 delete 语句可能永远不会被执行。
1
void process_data() {
2
MyObject* obj = new MyObject();
3
// ... 可能抛出异常的代码 ...
4
delete obj; // 如果上面抛出异常，这行代码不会执行，导致内存泄漏
5
}
▮▮▮▮⚝ unique_ptr 可以保证在发生异常时也能正确释放资源，因为它利用栈上对象的析构机制，即使栈展开 (stack unwinding) 发生，unique_ptr 的析构函数也会被调用。
1
void process_data_safe() {
2
std::unique_ptr<MyObject> obj = std::make_unique<MyObject>();
3
// ... 可能抛出异常的代码 ...
4
// obj 在函数结束或异常发生时自动析构并释放资源
5
}
③ 避免重复释放 (Double Free):
▮▮▮▮⚝ 裸指针容易出现对同一块内存调用两次 delete 的错误，这会导致未定义行为 (undefined behavior)，通常是程序崩溃。
▮▮▮▮⚝ unique_ptr 强制执行独占所有权 (exclusive ownership) 语义。同一时间只有一个 unique_ptr 对象可以管理特定的资源。这消除了多个指针意外地尝试释放同一资源的风险。
④ 避免野指针 (Dangling Pointer):
▮▮▮▮⚝ 当一个裸指针指向的内存被释放后，如果该指针没有被置为 nullptr，它就变成了野指针。继续使用野指针会导致未定义行为。
▮▮▮▮⚝ unique_ptr 在转移所有权 (ownership transfer) 后，原 unique_ptr 会被置为空 (nullptr)，这降低了出现野指针的概率。
⑤ 代码意图清晰 (Clear Code Intent):
▮▮▮▮⚝ 使用 unique_ptr 明确表达了资源的所有权语义：该资源由当前的 unique_ptr "拥有"，并且在其生命周期结束时负责清理。这使得代码的意图更加清晰易懂。
总而言之，使用 unique_ptr 是编写更安全、更健壮、更易于维护的现代 C++ 代码的关键一步。它自动化了繁琐且容易出错的内存管理任务，让开发者可以更专注于业务逻辑。
Appendix C2: unique_ptr 和 shared_ptr 有什么根本区别？我应该选择哪一个？
💡 回答: std::unique_ptr 和 std::shared_ptr 是 C++11 提供的两种主要的智能指针，它们最根本的区别在于对所管理资源所有权语义 (ownership semantics) 的处理方式。
① 所有权语义的区别:
▮▮▮▮⚝ unique_ptr: 实现独占所有权 (exclusive ownership)。意味着同一时刻只有一个 unique_ptr 可以指向并管理同一个对象。当 unique_ptr 被销毁时，它所管理的对象也会被销毁。所有权可以通过 std::move 进行转移。
▮▮▮▮⚝ shared_ptr: 实现共享所有权 (shared ownership)。多个 shared_ptr 可以同时指向并管理同一个对象。shared_ptr 内部维护一个引用计数 (reference count)。当最后一个指向该对象的 shared_ptr 被销毁或重置时，对象才会被销毁。
② 底层机制的区别:
▮▮▮▮⚝ unique_ptr: 通常非常轻量。它只包含一个指针（或者一个指针加上一个删除器对象），不涉及引用计数等额外开销。它的析构是 O(1) 操作。
▮▮▮▮⚝ shared_ptr: 相对重量。它包含一个指向对象的指针和一个指向控制块 (control block) 的指针。控制块包含引用计数和弱引用计数等信息。创建、复制、赋值 shared_ptr 会涉及原子操作来修改引用计数（在多线程环境下），这会有一定的性能开销。它的析构也是 O(1) 操作，但释放对象和控制块是额外操作。
③ 可拷贝性 (Copyability):
▮▮▮▮⚝ unique_ptr: 不可拷贝 (non-copyable)。只能通过移动语义 (move semantics) 进行所有权转移。
▮▮▮▮⚝ shared_ptr: 可拷贝 (copyable)。拷贝 shared_ptr 会增加引用计数。
④ 何时选择哪一个？
选择哪种智能指针取决于你的资源管理需求：
⚝ 选择 unique_ptr 的场景:
▮▮▮▮⚝ 当资源应该由一个且仅由一个所有者管理时。这是最常见的情况。
▮▮▮▮⚝ 当需要在不同作用域或函数之间转移资源的所有权时（使用 std::move）。
▮▮▮▮⚝ 当需要将对象存储在容器中，并且每个对象有独立的生命周期时。
▮▮▮▮⚝ 作为工厂函数的返回值，表示创建者将新对象的唯一所有权交给调用者。
▮▮▮▮⚝ 作为类的成员变量，表示类实例拥有并管理该资源。
▮▮▮▮⚝ 总之，优先考虑使用 unique_ptr。它更轻量、开销更低，并且清晰地表达了独占所有权的概念。只有当你明确需要共享所有权时，才考虑 shared_ptr。
⚝ 选择 shared_ptr 的场景:
▮▮▮▮⚝ 当多个部分的代码需要共享同一个资源的访问权，并且资源的生命周期由所有使用者共同决定时。
▮▮▮▮⚝ 例如，多个线程或对象需要访问同一个缓存数据或配置对象，直到最后一个使用者不再需要它时才释放。
记住一个简单的原则：默认使用 unique_ptr，仅在需要共享所有权时才使用 shared_ptr。
Appendix C3: 我可以直接拷贝 (copy) 一个 unique_ptr 吗？
🚫 回答: 不能。std::unique_ptr 是不可拷贝 (non-copyable) 的。它的拷贝构造函数 (copy constructor) 和拷贝赋值运算符 (copy assignment operator) 在 C++ 标准中被显式地标记为 deleted。
这是因为 unique_ptr 实现的是独占所有权 (exclusive ownership) 语义。如果一个 unique_ptr 可以被拷贝，那么就会有两个或多个 unique_ptr 同时指向并管理同一块内存。当其中一个 unique_ptr 超出作用域被销毁时，它会释放这块内存。此时，其他指向同一块内存的 unique_ptr 就变成了野指针 (dangling pointer)，并且当它们随后被销毁时，会尝试对已经被释放的内存再次进行释放，导致重复释放 (double free) 的未定义行为 (undefined behavior)。
例如，以下代码是不允许的，会导致编译错误：
1
#include <memory>
2
3
int main() {
4
std::unique_ptr<int> ptr1 = std::make_unique<int>(10);
5
// std::unique_ptr<int> ptr2 = ptr1; // 错误！unique_ptr 不可拷贝
6
// ptr1 = ptr2; // 错误！unique_ptr 不可拷贝赋值
7
return 0;
8
}
虽然 unique_ptr 不可拷贝，但它的所有权可以通过移动语义 (move semantics) 进行转移。这意味着你可以安全地将资源的管理权从一个 unique_ptr 转移给另一个。转移后，原来的 unique_ptr 将不再拥有该资源，通常会被置为 nullptr。
转移所有权的示例：
1
#include <memory>
2
#include <iostream>
3
4
int main() {
5
std::unique_ptr<int> ptr1 = std::make_unique<int>(10);
6
std::cout << "ptr1 is not null: " << (ptr1 != nullptr) << std::endl; // 输出 1 (true)
7
8
std::unique_ptr<int> ptr2 = std::move(ptr1); // 所有权从 ptr1 转移到 ptr2
9
10
std::cout << "After move:" << std::endl;
11
std::cout << "ptr1 is not null: " << (ptr1 != nullptr) << std::endl; // 输出 0 (false)
12
std::cout << "ptr2 is not null: " << (ptr2 != nullptr) << std::endl; // 输出 1 (true)
13
14
if (ptr2) {
15
std::cout << "Value via ptr2: " << *ptr2 << std::endl; // 输出 10
16
}
17
18
// ptr2 在 main 函数结束时自动释放内存
19
return 0;
20
}
通过 std::move，资源的所有权被清晰地从 ptr1 转移到了 ptr2。 ptr1 在转移后变为空，保证了同一资源只有一个有效的 unique_ptr 所有者。
Appendix C4: 如何将 unique_ptr 作为函数参数传递？
🔄️ 回答: 将 std::unique_ptr 作为函数参数传递时，传递方式取决于你希望函数如何与所有权交互。主要有两种方式：
① 通过右值引用 (Rvalue Reference) 传递 (转移所有权):
▮▮▮▮如果你希望函数接收资源的所有权，并在函数内部管理或最终释放它，可以将 unique_ptr 作为右值引用 (std::unique_ptr<T>&&) 参数传递。调用时需要使用 std::move 来显式地将所有权转移给函数。
1
#include <memory>
2
#include <iostream>
3
4
struct MyObject {
5
int id;
6
MyObject(int i) : id(i) { std::cout << "MyObject " << id << " created." << std::endl; }
7
~MyObject() { std::cout << "MyObject " << id << " destroyed." << std::endl; }
8
};
9
10
// 函数接收 unique_ptr 的所有权
11
void take_ownership(std::unique_ptr<MyObject>&& obj_ptr) {
12
if (obj_ptr) {
13
std::cout << "Function received object with id: " << obj_ptr->id << std::endl;
14
// 在函数内部，obj_ptr 现在是资源的唯一所有者
15
// 当 obj_ptr 在函数结束时超出作用域，对象会被销毁
16
} else {
17
std::cout << "Function received a null unique_ptr." << std::endl;
18
}
19
// obj_ptr 在此销毁 (如果非空，会释放资源)
20
}
21
22
int main() {
23
std::unique_ptr<MyObject> main_obj = std::make_unique<MyObject>(1);
24
std::cout << "Before calling take_ownership." << std::endl;
25
26
take_ownership(std::move(main_obj)); // 显式转移所有权
27
28
std::cout << "After calling take_ownership." << std::endl;
29
std::cout << "main_obj is null: " << (main_obj == nullptr) << std::endl; // 输出 1 (true)
30
31
// main_obj 在此销毁 (已经是空的 unique_ptr)
32
return 0;
33
}
特点: 调用后，传递的原始 unique_ptr 将变为空。
② 通过常量左值引用 (Const Lvalue Reference) 传递 (仅观察/使用，不转移所有权):
▮▮▮▮如果你只是想让函数访问 unique_ptr 所管理的资源，而不改变所有权关系或资源的生命周期，可以将 unique_ptr 作为常量左值引用 (const std::unique_ptr<T>&) 参数传递。在这种情况下，函数内部可以通过智能指针访问对象，但不能转移或释放所有权。
1
#include <memory>
2
#include <iostream>
3
4
struct MyObject {
5
int id;
6
MyObject(int i) : id(i) { std::cout << "MyObject " << id << " created." << std::endl; }
7
~MyObject() { std::cout << "MyObject " << id << " destroyed." << std::endl; }
8
};
9
10
// 函数仅访问资源，不改变所有权
11
void use_resource(const std::unique_ptr<MyObject>& obj_ptr) {
12
if (obj_ptr) {
13
std::cout << "Function accessing object with id: " << obj_ptr->id << std::endl;
14
// obj_ptr 是常量引用，不能调用 release() 或 reset() (非const版本)
15
} else {
16
std::cout << "Function received a null unique_ptr." << std::endl;
17
}
18
// obj_ptr 在此超出作用域，但不影响 main_obj 的所有权
19
}
20
21
int main() {
22
std::unique_ptr<MyObject> main_obj = std::make_unique<MyObject>(2);
23
std::cout << "Before calling use_resource." << std::endl;
24
25
use_resource(main_obj); // 传递常量引用
26
27
std::cout << "After calling use_resource." << std::endl;
28
std::cout << "main_obj is null: " << (main_obj == nullptr) << std::endl; // 输出 0 (false)
29
30
// main_obj 在此销毁并释放资源
31
return 0;
32
}
特点: 调用后，传递的原始 unique_ptr 仍然拥有资源。
③ 通过裸指针 (Raw Pointer) 传递:
▮▮▮▮有时，特别是与遗留 C 风格或 C++ 代码交互时，可能需要将底层裸指针 (T*) 传递给函数。你可以使用 unique_ptr::get() 方法获取裸指针。
1
#include <memory>
2
#include <iostream>
3
4
struct MyObject {
5
int id;
6
MyObject(int i) : id(i) { std::cout << "MyObject " << id << " created." << std::endl; }
7
~MyObject() { std::cout << "MyObject " << id << " destroyed." << std::endl; }
8
};
9
10
// 函数接收裸指针
11
void process_raw_pointer(MyObject* obj_ptr) {
12
if (obj_ptr) {
13
std::cout << "Function processing object with id: " << obj_ptr->id << std::endl;
14
// 注意：函数内部不应该 delete obj_ptr，否则会与 unique_ptr 的管理冲突！
15
} else {
16
std::cout << "Function received a null raw pointer." << std::endl;
17
}
18
}
19
20
int main() {
21
std::unique_ptr<MyObject> main_obj = std::make_unique<MyObject>(3);
22
std::cout << "Before calling process_raw_pointer." << std::endl;
23
24
process_raw_pointer(main_obj.get()); // 获取裸指针并传递
25
26
std::cout << "After calling process_raw_pointer." << std::endl;
27
std::cout << "main_obj is null: " << (main_obj == nullptr) << std::endl; // 输出 0 (false)
28
29
// main_obj 在此销毁并释放资源
30
return 0;
31
}
注意: 通过裸指针传递时，函数必须不负责释放资源。所有权仍然由 unique_ptr 保持。使用 get() 应该谨慎，确保不会在 unique_ptr 释放资源后继续使用裸指针。
总结:
⚝ 需要函数接管所有权：使用 std::unique_ptr<T>&& (右值引用)，调用时 std::move()。
⚝ 需要函数只访问资源：使用 const std::unique_ptr<T>& (常量左值引用)。
⚝ 需要与遗留 API 交互 (函数接收裸指针且不释放)：使用 T* 参数，调用时 unique_ptr::get()。
Appendix C5: 如何从函数返回一个 unique_ptr？
↩️ 回答: 从函数返回 std::unique_ptr 是转移资源所有权的一种非常常见且安全的方式，尤其适用于工厂函数 (factory function) 或其他创建并返回动态分配对象的函数。C++ 标准和编译器对返回 unique_ptr 提供了很好的优化。
① 直接返回新建的 unique_ptr:
▮▮▮▮最直接的方式是函数内部创建 unique_ptr 并直接返回。编译器通常会执行返回值优化 (Return Value Optimization, RVO) 或命名返回值优化 (Named Return Value Optimization, NRVO)，避免不必要的移动操作，实现高效返回。
1
#include <memory>
2
#include <iostream>
3
4
struct Product {
5
int id;
6
Product(int i) : id(i) { std::cout << "Product " << id << " created." << std::endl; }
7
~Product() { std::cout << "Product " << id << " destroyed." << std::endl; }
8
void operation() const { std::cout << "Product " << id << " performing operation." << std::endl; }
9
};
10
11
// 工厂函数，创建并返回 unique_ptr
12
std::unique_ptr<Product> create_product(int id) {
13
std::cout << "Inside create_product." << std::endl;
14
// 使用 std::make_unique (C++14+) 或 new Product(...)
15
auto p = std::make_unique<Product>(id);
16
// 编译器通常会优化掉这里的移动操作 (RVO/NRVO)
17
return p;
18
}
19
20
int main() {
21
std::cout << "Before calling create_product." << std::endl;
22
std::unique_ptr<Product> my_product = create_product(101); // 接收返回的 unique_ptr
23
std::cout << "After calling create_product." << std::endl;
24
25
if (my_product) {
26
my_product->operation();
27
}
28
29
std::cout << "End of main." << std::endl;
30
// my_product 在 main 函数结束时自动销毁并释放资源
31
return 0;
32
}
在这个例子中，即使没有显式使用 std::move(p) 在函数内部返回，C++ 标准规定，从函数返回局部 unique_ptr 对象时，如果返回类型是 unique_ptr，会自动应用移动语义。此外，RVO/NRVO 还能进一步优化，甚至可能直接在调用者的栈帧上构造 my_product，彻底消除移动操作。
② 返回经过 std::move 的 unique_ptr (通常不必要且可能阻止 RVO):
▮▮▮▮尽管规则允许，但通常不建议显式地对局部 unique_ptr 变量使用 std::move 来返回。显式 std::move 可能会阻止编译器执行 RVO/NRVO 优化，强制进行移动操作，这可能导致代码稍微变慢，并且没有带来额外的好处（因为标准已经保证了自动移动）。
1
// 不推荐这样做，可能阻止 RVO/NRVO
2
std::unique_ptr<Product> create_product_less_optimal(int id) {
3
std::cout << "Inside create_product_less_optimal." << std::endl;
4
auto p = std::make_unique<Product>(id);
5
return std::move(p); // 显式移动，可能阻止优化
6
}
只有在返回一个并非函数内部定义的局部变量（例如，返回一个通过参数传递进来的、你需要转移其所有权的 unique_ptr）时，才需要显式使用 std::move。
总结:
返回 unique_ptr 的最佳实践是直接返回你在函数内部创建并管理的 unique_ptr 局部变量。依靠 C++ 标准的自动移动语义和编译器的 RVO/NRVO 优化，这通常是最高效和最简洁的方式。
Appendix C6: 什么时候应该使用 std::make_unique 而不是直接用 new 创建 unique_ptr？
✨ 回答: 自 C++14 标准引入 std::make_unique 后，在绝大多数情况下，使用 std::make_unique 来创建 std::unique_ptr 优于 直接使用 new 然后将裸指针传递给 unique_ptr 的构造函数。其主要原因在于：
① 异常安全 (Exception Safety):
▮▮▮▮这是使用 std::make_unique 最重要的原因。考虑以下使用 new 的场景：
1
void process(const std::string& name, std::unique_ptr<MyObject> ptr); // 假设有这个函数
2
3
// 潜在异常不安全的代码
4
void foo(const std::string& name) {
5
process(name, std::unique_ptr<MyObject>(new MyObject(args))); // 参数创建顺序可能导致问题
6
}
在调用 process 函数时，函数的参数需要在调用前被评估 (evaluate)。假设 MyObject 的构造函数是 new MyObject(arg1, arg2, ...)，而 arg1, arg2 等参数的计算可能涉及函数调用或其他操作。编译器评估参数的顺序不是固定的（在 C++17 之前）。考虑表达式 process(expr1(), std::unique_ptr<MyObject>(new MyObject(expr2())))，可能的执行顺序是：
▮▮▮▮⚝ 调用 expr1()
▮▮▮▮⚝ 执行 new MyObject(expr2()) 中的 new MyObject(...)
▮▮▮▮⚝ 调用 expr2()
▮▮▮▮如果在执行 new MyObject(...) 之后，但在 std::unique_ptr 构造函数之前，调用 expr2() 抛出了异常，那么通过 new 分配的内存将永远不会被传递给 unique_ptr 的构造函数，导致内存泄漏 (memory leak)。
▮▮▮▮使用 std::make_unique 则完全规避了这个问题：
1
void foo_safe(const std::string& name) {
2
process(name, std::make_unique<MyObject>(args)); // 原子操作，异常安全
3
}
std::make_unique<MyObject>(args) 是一个单一的表达式，它负责对象的构造和 unique_ptr 的创建。如果在对象构造过程中抛出异常，内存分配会被取消，不会发生泄漏。如果在 std::make_unique 执行完成后（即 unique_ptr 已成功创建并管理资源）才抛出异常（例如在 process 函数内部），unique_ptr 的析构函数会确保内存被正确释放。
② 代码简洁性 (Conciseness):
▮▮▮▮使用 std::make_unique 代码更短，避免了重复类型名：
1
// 使用 new (较啰嗦)
2
std::unique_ptr<MyObject> ptr1(new MyObject(arg1, arg2));
3
4
// 使用 std::make_unique (简洁)
5
auto ptr2 = std::make_unique<MyObject>(arg1, arg2); // 优先使用 auto
简洁性也提高了代码的可读性。
③ 性能 (Performance):
▮▮▮▮虽然对于 unique_ptr 来说性能提升不如 shared_ptr 的 make_shared 那么显著（make_shared 可以一次性分配对象和控制块的内存），但 make_unique 依然避免了两次类型名的查找，理论上编译器有更大的优化空间。
不适用 std::make_unique 的少数情况:
尽管 std::make_unique 强烈推荐，但在以下几种情况下可能需要直接使用 new：
▮▮▮▮⚝ 需要定制删除器 (custom deleter): std::make_unique 不支持直接指定定制删除器。在这种情况下，你需要先用 new 创建对象，然后将裸指针和定制删除器一起传递给 unique_ptr 的构造函数。
1
auto file_closer = [](FILE* f){ if(f) fclose(f); };
2
// FILE* f = fopen("my_file.txt", "r"); // 假设打开成功
3
// std::unique_ptr<FILE, decltype(file_closer)> file_ptr(f, file_closer); // 需要 new + deleter 形式的 unique_ptr 构造
4
// 实际上 unique_ptr<FILE, ...> 是可以由 FILE* + deleter 构造的
5
// 更常见的定制删除器场景可能涉及 class Type* with delete[] or custom cleanup func
6
// 例如:
7
struct MyData { /* ... */ };
8
struct MyDeleter { void operator()(MyData* p) const { /* custom cleanup */ delete p; } };
9
std::unique_ptr<MyData, MyDeleter> data_ptr(new MyData(), MyDeleter()); // 不能用 make_unique
▮▮▮▮⚝ 使用花括号初始化列表 (initializer list): 在 C++14 中，std::make_unique 不支持花括号初始化列表。但这个限制在 C++17 中已被移除。所以在 C++17 及更高版本中，你可以对支持初始化列表的类型（如数组或某些类）使用 std::make_unique 和初始化列表。
1
// C++17 及更高版本支持
2
// auto arr_ptr = std::make_unique<int[]>(5); // 创建一个 int[5] 的数组
3
// auto vec_ptr = std::make_unique<std::vector<int>>(std::initializer_list<int>{1, 2, 3});
总结:
除了需要定制删除器或在 C++14 中使用初始化列表的特殊情况外，总是优先使用 std::make_unique 来创建 std::unique_ptr，因为它更安全、更简洁，且性能通常没有劣势。
Appendix C7: 如何获取 unique_ptr 所管理的底层裸指针 (raw pointer)？这样做安全吗？
🕵️ 回答: 你可以使用 std::unique_ptr::get() 成员函数来获取 unique_ptr 当前管理的对象的底层裸指针 (raw pointer)。
1
#include <memory>
2
#include <iostream>
3
4
int main() {
5
std::unique_ptr<int> ptr = std::make_unique<int>(100);
6
7
int* raw_ptr = ptr.get(); // 获取底层裸指针
8
9
if (raw_ptr) {
10
std::cout << "Value via unique_ptr: " << *ptr << std::endl; // 访问通过 unique_ptr
11
std::cout << "Value via raw pointer: " << *raw_ptr << std::endl; // 访问通过裸指针
12
// 它们指向同一个对象
13
}
14
15
// 裸指针 raw_ptr 仍然指向对象
16
// ptr 在这里超出作用域，释放对象
17
18
// 警告：不要在 ptr 释放后使用 raw_ptr！
19
// std::cout << "Value via raw pointer after unique_ptr freed: " << *raw_ptr << std::endl; // 危险！未定义行为！
20
21
return 0;
22
}
安全性问题:
获取 unique_ptr 的底层裸指针通常是安全的，前提是你知道自己在做什么，并且严格遵守以下原则：
① 不要使用 get() 返回的指针来释放资源:
▮▮▮▮绝不能对 get() 返回的指针调用 delete 或 delete[]。资源的所有权完全由 unique_ptr 管理，它会负责释放。如果你手动释放了资源，当 unique_ptr 随后被销毁时，它将尝试再次释放已经无效的内存，导致重复释放 (double free) 和未定义行为 (undefined behavior)。
② get() 返回的指针的生命周期:
▮▮▮▮get() 返回的裸指针的有效性与 unique_ptr 所管理的对象的生命周期绑定。一旦 unique_ptr 被销毁、重置 (reset()) 或所有权被转移 (release() 或通过移动赋值)，它所管理的资源就会被释放（除非使用了 release()）。此时，通过之前调用 get() 获得的裸指针就变成了野指针 (dangling pointer)，对其进行任何操作（解引用、访问成员等）都会导致未定义行为。
③ 何时使用 get() 是合适的:
▮▮▮▮⚝ 与遗留 C 或 C++ API 交互: 很多旧的库函数接受裸指针作为参数。在这种情况下，使用 ptr.get() 是将智能指针管理的资源暴露给这些函数的方式。
1
// 假设有一个遗留函数：
2
// void legacy_api(MyObject* obj);
3
// legacy_api(ptr.get()); // 安全地传递裸指针
确保 legacy_api 函数不会删除传递进来的指针！
▮▮▮▮⚝ 检查指针是否为空: 虽然通常可以直接 if (ptr), if (!ptr) 或 if (ptr != nullptr) 来检查 unique_ptr 是否管理着资源，但有时为了与其他裸指针逻辑保持一致，也可能使用 ptr.get() == nullptr 进行检查。不过直接使用 if (ptr) 更推荐。
总结:
get() 方法本身是安全的，它只是返回底层指针的值。不安全的是在 unique_ptr 已经放弃或释放了资源后，继续使用通过 get() 获取的那个裸指针。务必确保在使用裸指针时，其对应的 unique_ptr 仍然有效并管理着该资源。通常，能不使用 get() 就尽量避免，除非确实需要与裸指针接口交互。
Appendix C8: unique_ptr 的 release() 和 reset() 方法有什么区别？
🔄️ 回答: std::unique_ptr 的 release() 和 reset() 方法都涉及改变 unique_ptr 所管理的对象，但它们的作用和后果截然不同：
① release() 方法:
▮▮▮▮⚝ 作用: release() 方法放弃 unique_ptr 对其当前所管理资源的所有权 (ownership)。它返回指向该资源的裸指针 (raw pointer)，并将 unique_ptr 内部的指针置为 nullptr。
▮▮▮▮⚝ 后果: 调用 release() 后，unique_ptr 不再负责释放资源。现在你有了一个裸指针，你必须手动负责该资源的生命周期管理（例如，在适当的时候对其调用 delete 或 delete[]），否则会导致内存泄漏 (memory leak)。
▮▮▮▮⚝ 返回类型: 返回 pointer 类型，即底层裸指针。
▮▮▮▮⚝ 示例:
1
#include <memory>
2
#include <iostream>
3
4
struct MyObject {
5
int id;
6
MyObject(int i) : id(i) { std::cout << "MyObject " << id << " created." << std::endl; }
7
~MyObject() { std::cout << "MyObject " << id << " destroyed." << std::endl; }
8
};
9
10
int main() {
11
std::unique_ptr<MyObject> ptr = std::make_unique<MyObject>(1);
12
std::cout << "Before release, ptr is null: " << (ptr == nullptr) << std::endl; // 输出 0 (false)
13
14
MyObject* raw_ptr = ptr.release(); // 释放所有权并获取裸指针
15
std::cout << "After release, ptr is null: " << (ptr == nullptr) << std::endl; // 输出 1 (true)
16
17
if (raw_ptr) {
18
std::cout << "Raw pointer value: " << raw_ptr->id << std::endl; // 可以使用裸指针
19
// 现在你有责任释放这块内存！
20
delete raw_ptr; // 手动释放资源
21
}
22
23
// ptr 在此销毁 (已经是空的 unique_ptr)
24
// raw_ptr 不应该在这里使用，它指向的内存已经释放
25
return 0;
26
}
▮▮▮▮⚝ 使用场景: release() 主要用于需要将资源所有权“导出”到旧的 C/C++ 接口中，这些接口期望接收并管理一个裸指针。使用时务必小心，确保新的所有者会正确释放资源。
② reset() 方法:
▮▮▮▮⚝ 作用: reset() 方法使 unique_ptr 停止管理当前的对象（如果存在），并可选地开始管理一个新的对象。
▮▮▮▮⚝ 后果:
▮▮▮▮⚝ 如果 unique_ptr 当前管理着一个对象，reset() 会先调用删除器 (deleter) 释放当前对象占用的资源。
▮▮▮▮⚝ 然后，unique_ptr 会更新其内部指针，指向 reset() 的参数（一个新的裸指针）。
▮▮▮▮⚝ 如果 reset() 的参数是 nullptr 或者没有参数（默认是 nullptr），unique_ptr 将变为空，不再管理任何资源（释放旧资源后）。
▮▮▮▮⚝ 返回类型: void.
▮▮▮▮⚝ 重载形式:
▮▮▮▮⚝ void reset(pointer ptr = pointer()); // 停止管理当前对象，开始管理 ptr
▮▮▮▮⚝ void reset(nullptr_t); // 停止管理当前对象，变为空
▮▮▮▮⚝ 示例:
1
#include <memory>
2
#include <iostream>
3
4
struct MyObject {
5
int id;
6
MyObject(int i) : id(i) { std::cout << "MyObject " << id << " created." << std::endl; }
7
~MyObject() { std::cout << "MyObject " << id << " destroyed." << std::endl; }
8
};
9
10
int main() {
11
std::unique_ptr<MyObject> ptr = std::make_unique<MyObject>(1);
12
std::cout << "ptr manages id: " << ptr->id << std::endl;
13
14
std::cout << "Resetting ptr to manage new object..." << std::endl;
15
// ptr 释放旧的 MyObject(1)，开始管理新的 MyObject(2)
16
ptr.reset(new MyObject(2));
17
std::cout << "ptr now manages id: " << ptr->id << std::endl;
18
19
std::cout << "Resetting ptr to nullptr..." << std::endl;
20
ptr.reset(); // ptr 释放旧的 MyObject(2)，变为空
21
std::cout << "ptr is null: " << (ptr == nullptr) << std::endl; // 输出 1 (true)
22
23
// ptr 在此销毁 (已经是空的 unique_ptr)
24
return 0;
25
}
▮▮▮▮⚝ 使用场景: reset() 常用于让 unique_ptr 放弃当前资源并接管另一个新资源，或者显式地让 unique_ptr 提前释放资源（通过 reset() 或 reset(nullptr)）。
核心区别总结:
⚝ release(): 放弃所有权，返回裸指针，调用者需手动管理后续生命周期。unique_ptr 变为空。
⚝ reset(): 替换或清空所管理的资源。如果原来有资源，先释放旧的，然后可以管理新的资源（或变为空）。所有权始终由 unique_ptr 管理。
使用 release() 必须极其小心，因为它将管理责任转回裸指针，容易引入内存泄漏；而 reset() 是在智能指针内部安全地替换或清空资源。
Appendix C9: 我如何使用 unique_ptr 管理动态分配的数组？
📦 回答: std::unique_ptr 提供了一个特化版本，用于正确管理动态分配的数组。这个特化版本会自动使用 delete[] 而不是 delete 来释放内存。
要使用 unique_ptr 管理数组，你需要指定类型为 T[]：
1
std::unique_ptr<int[]> unique_array;
2
std::unique_ptr<MyObject[]> unique_object_array;
① 创建 unique_ptr<T[]>:
▮▮▮▮推荐方式 (C++14+): 使用 std::make_unique 的数组版本。你需要提供数组的大小。
1
#include <memory>
2
#include <iostream>
3
4
int main() {
5
// 创建一个包含 5 个 int 的动态数组
6
auto arr_ptr = std::make_unique<int[]>(5);
7
8
// 访问数组元素
9
for (int i = 0; i < 5; ++i) {
10
arr_ptr[i] = (i + 1) * 10;
11
std::cout << "arr_ptr[" << i << "] = " << arr_ptr[i] << std::endl;
12
}
13
14
// arr_ptr 在 main 函数结束时自动调用 delete[] 释放内存
15
return 0;
16
}
▮▮▮▮旧方式 (C++11): 使用 new 分配数组，然后传递给 unique_ptr<T[]> 的构造函数。
1
#include <memory>
2
#include <iostream>
3
4
int main() {
5
// C++11 方式创建数组
6
std::unique_ptr<double[]> arr_ptr(new double[3]);
7
8
arr_ptr[0] = 1.1;
9
arr_ptr[1] = 2.2;
10
arr_ptr[2] = 3.3;
11
12
for (int i = 0; i < 3; ++i) {
13
std::cout << "arr_ptr[" << i << "] = " << arr_ptr[i] << std::endl;
14
}
15
16
// arr_ptr 在 main 函数结束时自动调用 delete[] 释放内存
17
return 0;
18
}
强烈建议使用 std::make_unique 版本，因为它更安全且简洁（参见 FAQ C6）。
② 访问数组元素:
▮▮▮▮unique_ptr<T[]> 重载了 operator[]，可以像使用普通指针一样通过索引访问数组元素。
1
arr_ptr[i]; // 访问第 i 个元素
③ 释放资源:
▮▮▮▮unique_ptr<T[]> 的特化版本在析构时会自动调用 delete[] 来释放整个数组内存，无需手动干预。
④ 重要限制:
▮▮▮▮⚝ unique_ptr<T[]> 没有提供 operator* 或 operator->，因为这些运算符对整个数组而言没有明确的含义。
▮▮▮▮⚝ unique_ptr<T[]> 不知道数组的大小。一旦创建，你无法通过 unique_ptr 对象本身获取数组的长度。你需要自己存储数组的大小。
总结:
使用 unique_ptr<T[]> 是管理动态分配数组的安全有效方式。优先使用 std::make_unique<T[]>(size) 进行创建，并通过 operator[] 访问元素。记住它负责 delete[]，但不能获取数组大小。
Appendix C10: 什么是定制删除器 (custom deleter)？我为什么需要它？
🔧 回答: 定制删除器 (custom deleter) 是一个用于代替 std::unique_ptr 默认 delete 或 delete[] 行为的函数或函数对象 (functor)。它允许你定义在 unique_ptr 销毁时如何释放或清理其管理的资源。
为什么需要定制删除器？
默认的 unique_ptr 行为是使用 delete（对于单个对象）或 delete[]（对于数组）来释放内存。然而，并非所有需要 RAII (Resource Acquisition Is Initialization) 管理的“资源”都是通过 new 分配的内存。资源可以是：
① 通过 C 风格函数获取的句柄或指针:
▮▮▮▮例如，文件句柄 (FILE*，通过 fopen 获取，需要 fclose 释放)，系统资源句柄（如 Win32 API 中的句柄，需要特定的 CloseHandle 函数），网络套接字 (socket) 等。这些资源不能简单地用 delete 来释放。
② 需要特殊清理逻辑的内存:
▮▮▮▮比如，通过特定的内存池分配器 (allocator) 分配的内存，或者在释放前需要执行某些清理操作的对象。
③ 数组但不是通过 new[] 分配:
▮▮▮▮虽然少见，但理论上存在。
通过提供定制删除器，你可以将这些非标准资源的释放或清理逻辑封装在 unique_ptr 中，从而享受 unique_ptr 提供的自动管理和异常安全特性。
如何使用定制删除器？
定制删除器作为 unique_ptr 模板的第二个参数指定。它可以是：
① 函数指针 (Function Pointer):
1
#include <memory>
2
#include <cstdio> // for FILE, fopen, fclose
3
4
// 定义一个函数，它接受 FILE* 并关闭文件
5
void close_file(FILE* f) {
6
if (f) {
7
fclose(f);
8
std::puts("File closed by custom deleter.");
9
}
10
}
11
12
int main() {
13
// unique_ptr 的类型需要包含删除器的类型
14
std::unique_ptr<FILE, void(*)(FILE*)> file_ptr(std::fopen("my_test_file.txt", "w"), &close_file);
15
16
if (file_ptr) {
17
std::fputs("Hello, unique_ptr!\n", file_ptr.get());
18
std::cout << "File opened and written." << std::endl;
19
} else {
20
std::cerr << "Failed to open file." << std::endl;
21
}
22
23
// file_ptr 在这里超出作用域，close_file 函数会被调用
24
return 0;
25
}
注意 unique_ptr 的类型声明 std::unique_ptr<FILE, void(*)(FILE*)> 包含了函数指针的类型。
② 函数对象 (Functor) 或 Lambda 表达式 (Lambda Expression):
▮▮▮▮使用函数对象或 Lambda 表达式通常更灵活，尤其是对于需要捕获上下文信息或类型推导的情况。Lambda 表达式在现代 C++ 中非常常用。
1
#include <memory>
2
#include <iostream>
3
4
struct MyObject {
5
int id;
6
MyObject(int i) : id(i) { std::cout << "MyObject " << id << " created." << std::endl; }
7
~MyObject() { std::cout << "MyObject " << id << " destroyed." << std::endl; }
8
};
9
10
// 定义一个函数对象作为删除器
11
struct ObjectDeleter {
12
void operator()(MyObject* p) const {
13
std::cout << "Using custom ObjectDeleter for id " << p->id << std::endl;
14
delete p; // 调用默认 delete 释放内存，但可以加入其他逻辑
15
}
16
};
17
18
int main() {
19
// unique_ptr 的类型需要包含删除器的类型
20
std::unique_ptr<MyObject, ObjectDeleter> obj_ptr1(new MyObject(10));
21
22
// 使用 Lambda 表达式作为删除器 (推荐 C++11+)
23
// unique_ptr 的类型可以由 Lambda 推导，但通常需要显式声明
24
// 如果 Lambda 不捕获任何变量，其类型可以转换为函数指针
25
auto lambda_deleter = [](MyObject* p) {
26
std::cout << "Using lambda deleter for id " << p->id << std::endl;
27
delete p;
28
};
29
30
std::unique_ptr<MyObject, decltype(lambda_deleter)> obj_ptr2(new MyObject(20), lambda_deleter);
31
32
// obj_ptr1 和 obj_ptr2 在这里超出作用域，各自的定制删除器会被调用
33
return 0;
34
}
使用 Lambda 表达式时，如果它没有捕获任何变量，其类型可以隐式转换为函数指针类型。如果 Lambda 捕获了变量（例如，需要访问外部状态来决定如何删除），它是一个有状态的函数对象，你需要使用 decltype(lambda_deleter) 来指定删除器的类型。
删除器对 unique_ptr 类型和大小的影响:
▮▮▮▮删除器的类型是 unique_ptr 类型的一部分。这意味着 std::unique_ptr<T> 和 std::unique_ptr<T, SomeDeleter> 是不同的类型。
▮▮▮▮删除器是否有状态（即是否需要存储额外的成员变量，例如 Lambda 捕获了变量）会影响 unique_ptr 对象的大小。无状态的删除器（如函数指针或不捕获的 Lambda）通常可以通过空基类优化 (Empty Base Optimization) 使 unique_ptr 的大小与裸指针相同。有状态的删除器会增加 unique_ptr 对象的大小，因为它需要存储删除器的实例。
总结:
定制删除器是 unique_ptr 实现通用资源管理的关键。它使得 unique_ptr 不仅限于管理 new 分配的内存，还能安全地管理各种需要清理的资源，并通过 RAII 机制确保资源在适当时候被释放，极大地提高了代码的健壮性。使用函数对象或 Lambda 表达式通常是定义定制删除器的推荐方式。
Appendix C11: unique_ptr 是线程安全的吗？
🚧 回答: std::unique_ptr 对象本身不是线程安全 (thread-safe) 的。这意味着，如果多个线程需要同时访问同一个 unique_ptr 对象（例如，调用其成员函数、赋值等），你需要外部同步机制（如互斥锁 std::mutex）来保护对该 unique_ptr 对象的并发访问。
让我们明确“线程安全”在这里的含义：
① 对同一个 unique_ptr 对象的并发访问:
▮▮▮▮如果两个线程尝试同时调用同一个 unique_ptr 对象的方法（如 get(), reset(), release(), 或赋值操作符 =)，而没有适当的同步，这会导致数据竞争 (data race) 和未定义行为 (undefined behavior)。例如，一个线程正在调用 reset() 释放资源，而另一个线程同时调用 get() 获取裸指针去使用，这就会出错。
1
// 这是一个不安全的例子 (伪代码)
2
std::unique_ptr<MyObject> global_ptr = std::make_unique<MyObject>(1);
3
4
// 线程 1: 尝试使用 global_ptr
5
void thread_func1() {
6
// 潜在的数据竞争：global_ptr 可能在任何时候被其他线程修改或变空
7
if (global_ptr) {
8
global_ptr->operation(); // 如果 global_ptr 在此行之前被其他线程 reset 或 release，将导致未定义行为
9
}
10
}
11
12
// 线程 2: 尝试重置 global_ptr
13
void thread_func2() {
14
// 潜在的数据竞争：修改 global_ptr 对象本身的状态
15
global_ptr.reset(new MyObject(2));
16
}
17
18
// main 函数中创建并启动 thread_func1 和 thread_func2...
19
// 需要同步来保护 global_ptr
要安全地在多个线程之间共享和操作一个 unique_ptr 对象，你需要使用互斥锁：
1
std::unique_ptr<MyObject> global_ptr_safe = std::make_unique<MyObject>(1);
2
std::mutex global_ptr_mutex;
3
4
void thread_func_safe1() {
5
std::lock_guard<std::mutex> lock(global_ptr_mutex); // 加锁保护访问
6
if (global_ptr_safe) {
7
global_ptr_safe->operation();
8
}
9
}
10
11
void thread_func_safe2() {
12
std::lock_guard<std::mutex> lock(global_ptr_mutex); // 加锁保护访问
13
global_ptr_safe.reset(new MyObject(2));
14
}
② 通过 unique_ptr 访问底层资源的线程安全:
▮▮▮▮unique_ptr 对其管理的底层对象不提供任何线程安全保证。如果你通过 unique_ptr（或通过 get() 获取的裸指针）访问底层的对象，而这个对象的状态可能被其他线程同时修改，那么你需要保证对底层对象本身的访问是线程安全的。这通常意味着底层对象的成员函数本身需要是线程安全的，或者你需要通过其他同步机制来保护对底层对象的访问。
③ unique_ptr 所有权的线程间转移:
▮▮▮▮unique_ptr 可以安全地在线程之间转移所有权 (transfer ownership)。这是通过移动语义实现的。一个线程可以将一个 unique_ptr 的所有权转移给另一个线程（例如，通过将 unique_ptr 放入一个线程安全的队列，或者作为线程函数的参数传递）。一旦所有权转移完成，原线程就不再访问或管理该资源，新线程成为唯一的管理者。
1
#include <memory>
2
#include <thread>
3
#include <iostream>
4
#include <utility> // for std::move
5
6
struct Task {
7
int id;
8
Task(int i) : id(i) { std::cout << "Task " << id << " created on thread " << std::this_thread::get_id() << std::endl; }
9
~Task() { std::cout << "Task " << id << " destroyed on thread " << std::this_thread::get_id() << std::endl; }
10
void execute() { std::cout << "Task " << id << " executing on thread " << std::this_thread::get_id() << std::endl; }
11
};
12
13
void process_task(std::unique_ptr<Task> task_ptr) { // 函数接收 unique_ptr 所有权
14
if (task_ptr) {
15
task_ptr->execute();
16
}
17
// task_ptr 在此超出作用域，在当前线程中销毁 Task 对象
18
}
19
20
int main() {
21
std::cout << "Main thread id: " << std::this_thread::get_id() << std::endl;
22
std::unique_ptr<Task> main_task = std::make_unique<Task>(1);
23
24
std::thread worker_thread(process_task, std::move(main_task)); // 启动新线程并将所有权转移给它
25
26
std::cout << "main_task is null after move: " << (main_task == nullptr) << std::endl; // 输出 1 (true)
27
28
worker_thread.join(); // 等待工作线程完成
29
30
std::cout << "End of main." << std::endl;
31
return 0;
32
}
在这个例子中，main_task 的所有权从主线程转移到了 worker_thread。对象 Task(1) 的创建发生在主线程，但销毁发生 process_task 函数所在的 worker_thread。这种所有权转移本身是线程安全的。
总结:
unique_ptr 对象本身不适合在多个线程之间共享和修改，除非有外部同步。然而，它管理资源的生命周期是可靠的，并且其所有权可以安全地在线程之间转移。如果你需要在多个线程之间共享同一个对象实例并进行并发访问，通常应该考虑使用 std::shared_ptr (虽然 shared_ptr 自身的引用计数操作是原子的，但对它管理的底层对象的访问同样需要额外的同步)。
Appendix C12: unique_ptr 的性能开销如何？
⚡ 回答: std::unique_ptr 设计目标之一就是提供与裸指针 (raw pointer) 相媲美的性能开销 (performance overhead)。在绝大多数情况下，unique_ptr 在运行时几乎是零开销的。
原因如下：
① 存储开销 (Storage Overhead):
▮▮▮▮一个 std::unique_ptr<T> 对象通常只占用与一个裸指针 (T*) 相同的内存大小。如果使用了无状态的定制删除器（如函数指针或不捕获任何变量的 Lambda ），得益于空基类优化 (Empty Base Optimization)，unique_ptr 的大小仍然是一个指针的大小。只有当使用了有状态的定制删除器时，unique_ptr 的大小才会增加，以存储删除器对象。
② 构造和析构开销 (Construction and Destruction Overhead):
▮▮▮▮unique_ptr 的构造和析构开销极低。
▮▮▮▮⚝ 构造: 创建一个 unique_ptr（例如通过 std::make_unique 或构造函数）的开销主要是底层对象的构造开销，unique_ptr 本身的构造是微不足道的，只是初始化一个指针。
▮▮▮▮⚝ 析构: unique_ptr 的析构函数是 O(1) 操作。它仅仅检查内部指针是否为空，如果非空，则调用删除器（通常是 delete 或定制删除器）。这个过程与手动调用 delete 的开销相当。
③ 访问开销 (Access Overhead):
▮▮▮▮通过 unique_ptr 的 operator* 或 operator-> 访问底层对象几乎没有额外的开销。这些操作通常会被编译器优化为直接对底层裸指针的访问。
④ 移动操作开销 (Move Operation Overhead):
▮▮▮▮unique_ptr 的移动构造和移动赋值操作也是 O(1) 操作。它们只是简单地将底层指针从源 unique_ptr 复制到目标 unique_ptr，然后将源 unique_ptr 的指针置为 nullptr。这比拷贝一个对象（如果 unique_ptr 可拷贝的话）要高效得多。
⑤ 与 std::make_unique 的配合:
▮▮▮▮使用 std::make_unique (C++14+) 创建 unique_ptr 时，编译器有更大的优化空间，尤其是在涉及到返回值优化 (RVO/NRVO) 的场景，可以进一步提高效率并避免不必要的移动操作。
与 shared_ptr 的性能对比:
与 std::shared_ptr 相比，unique_ptr 的性能优势通常体现在：
▮▮▮▮⚝ 更低的存储开销: shared_ptr 需要额外的控制块来存储引用计数等信息，通常是两个指针的大小。
▮▮▮▮⚝ 更低的运行时开销: shared_ptr 的拷贝、赋值、析构等操作涉及到对引用计数的原子操作（为了线程安全），这会带来一定的开销。而 unique_ptr 不涉及这些。
因此，当你不需要共享所有权时，使用 unique_ptr 可以获得更高的性能，尤其是在性能敏感的代码部分或者创建大量智能指针的场景下。
总结:
unique_ptr 是一个高性能的智能指针，其设计使其在运行时与裸指针具有接近的性能。它提供自动资源管理和异常安全，而不会引入显著的额外开销。优先选择 unique_ptr 是现代 C++ 中兼顾安全与性能的推荐做法。
Appendix D: 参考文献与进一步阅读 (References and Further Reading)
理解 C++ 的 unique_ptr 不仅需要掌握其自身的使用方法，还需要深入理解其背后的现代 C++ 特性，如 RAII 原则（Resource Acquisition Is Initialization）、移动语义（Move Semantics）以及异常安全（Exception Safety）等。此外，将其置于整个 C++ 智能指针家族和现代 C++ 生态系统中进行考察，有助于形成更全面、更深入的认识。本附录列出了撰写本书时参考的一些关键文献和权威资源，同时也推荐了一些可供读者进一步深入学习的资料。📚
这些资料涵盖了 C++ 标准、经典书籍、技术博客以及在线参考文档，旨在为不同层次的读者提供继续学习的途径。
Appendix D1: C++ 标准文档 (C++ Standard Documents)
C++ 标准文档是理解 C++ 语言特性最权威的来源。虽然它们通常以技术规范的形式呈现，阅读起来可能较为困难，但对于深入探究细节和理解语言的设计意图至关重要。
① C++11 标准 (ISO/IEC 14882:2011)
▮▮▮▮这是 std::unique_ptr 被首次引入的标准版本。它定义了 unique_ptr 的基本概念、接口和所有权语义。查阅标准文档中关于 <memory> 头文件的部分，可以找到 unique_ptr 的精确规范。
② C++14 标准 (ISO/IEC 14882:2014)
▮▮▮▮C++14 标准库中引入了 std::make_unique 函数模板，这是创建 unique_ptr 的推荐方式。
③ 后续 C++ 标准 (C++17, C++20 等)
▮▮▮▮虽然后续标准没有对 unique_ptr 本身进行重大修改，但它们引入了其他可能与智能指针使用相关的特性（例如，结构化绑定 Structured Bindings 可能与 unique_ptr 结合使用，或者其他库特性可能返回 unique_ptr）。了解最新的标准有助于掌握 unique_ptr 在现代代码中的最新应用模式。
Appendix D2: 经典 C++ 书籍 (Classic C++ Books)
以下是一些在 C++ 领域极具影响力的书籍，它们都不同程度地深入讨论了智能指针、资源管理和现代 C++ 编程实践。
① Effective Modern C++ (Scott Meyers)
▮▮▮▮这本书是学习现代 C++ (C++11/14) 的必读经典。其中有专门的章节（如 Item 18 到 Item 23）详细探讨了 std::unique_ptr、std::shared_ptr 以及何时、如何选择和使用它们，包括 make_unique 和 make_shared 的使用建议、定制删除器等。Meyers 以其深入浅出的分析和实用的建议而闻名。
② Effective C++ (Third Edition) (Scott Meyers)
▮▮▮▮这本书是 C++ 11 之前的经典，但其中关于 RAII（Item 13）、资源管理对象（Item 14）以及 auto_ptr（Item 19）的讨论，对于理解智能指针的历史背景和设计思想非常有价值。尽管 auto_ptr 已废弃，但理解其不足之处有助于认识 unique_ptr 的改进。
③ The C++ Programming Language (Fourth Edition) (Bjarne Stroustrup)
▮▮▮▮C++ 语言的创造者 Bjarne Stroustrup 撰写的权威著作。第四版全面介绍了 C++11 及以后的特性，包括智能指针。书中对智能指针的设计原理和在语言中的定位有宏观且深刻的阐述。
④ C++ Primer (Fifth Edition) (Stanley B. Lippman, Josée Lajoie, Barbara E. Moo)
▮▮▮▮这本书是一本优秀的入门和中级教程，内容详实且易于理解。它对智能指针（包括 unique_ptr）的介绍非常系统，适合初学者建立扎实的基础。书中提供了大量的示例代码，帮助读者理解智能指针的用法和语义。
⑤ Exceptional C++ / More Exceptional C++ (Herb Sutter)
▮▮▮▮这两本书虽然不是专门关于智能指针，但它们深入讨论了异常安全编程。理解 unique_ptr 如何通过 RAII 保证异常安全是掌握其高级用法的关键，这两本书提供了关于异常安全的宝贵见解。
Appendix D3: 在线资源 (Online Resources)
互联网上有大量高质量的 C++ 学习资源，特别是针对标准库特性。
① cppreference.com
▮▮▮▮这是一个极其重要的 C++ 参考网站，提供了 C++ 标准库（包括 <memory> 头文件中的 unique_ptr 和 make_unique）的详细文档、示例代码和技术细节。它是查找特定函数或类用法最快捷、最准确的资源之一。
② C++ Core Guidelines (isocpp.github.io/CppCoreGuidelines/)
▮▮▮▮由 Bjarne Stroustrup 和 Herb Sutter 等 C++ 专家主导的编程规范。其中包含关于资源管理和指针使用的具体指南（如 R.5: Prefer scoped objects, avoid heap allocation if possible; R.20: Adopt RAII at the earliest opportunity; R.21: Prefer unique_ptr or shared_ptr to owning *. etc.）。遵循这些指南有助于写出更健壮、更易维护的代码。
③ 各大 C++ 技术博客和网站
▮▮▮▮如 Fluent C++ (Franck Pasquier)、Modern C++ (Bartłomiej Filipek)、Stack Overflow 等。这些平台上有许多关于智能指针的优秀文章、教程和问答，涵盖了从基础到高级的各种问题和技巧。通过阅读这些资源，可以学习到最新的实践经验和解决特定问题的方案。
Appendix D4: C++ 标准提案 (C++ Standard Proposals)
对于希望深入了解智能指针设计动机和演进过程的读者，查阅相关的标准提案文件是非常有益的。这些提案记录了新特性被加入标准的原因、讨论过程和最终设计。
① N2679: A Proposal to Add a Polymorphic Smart Pointer to the Standard Library (Bjarne Stroustrup, Herb Sutter, Bill Gibbons)
▮▮▮▮这是早期讨论 C++11 标准智能指针（包括 shared_ptr 和 unique_ptr 的前身概念）的提案之一。
② N2983: A proposal to add move semantics to the library (Howard Hinnant, Alisdair Meredith, Jonathan Caves)
▮▮▮▮这份提案详细描述了移动语义的设计和动机，理解移动语义对于掌握 unique_ptr 的所有权转移至关重要。
③ N3588: make_unique (Stefanus Du Toit)
▮▮▮▮这份提案是关于将 make_unique 添加到 C++14 标准库的动机和具体实现细节。
Appendix D5: 总结 (Conclusion)
以上列出的资源构成了学习和掌握 C++ unique_ptr 的重要基石。从权威的标准文档理解其精确行为，通过经典书籍系统学习其原理和最佳实践，利用在线资源查阅细节和获取最新的社区经验，以及深入研究标准提案理解其设计背景，这些多维度的学习方法将帮助读者不仅“会用” unique_ptr，更能“理解”它，从而在实际开发中游刃有余地运用这一强大的现代 C++ 工具。不断学习和实践，是成为优秀 C++ 程序员的必由之路。🏁