智能指针详解

第 1 章 学习目标与导论

1.1 本章在 C++ 知识体系中的位置

智能指针（smart pointer，由 David Klappholz 与 Peter Wegner 于 1987 年在面向对象编程文献中首次提出，“smart” 隐喻其具备自动管理资源的”智能”行为，与”哑指针（dumb pointer）“即裸指针相对）是现代 C++ 资源管理的核心抽象。它位于 C++ 知识体系的”所有权层”，向上承接 cpp/指针 中的裸指针机制，向下衔接 cpp/RAII资源管理、cpp/右值引用与移动语义、cpp/模板元编程 等现代 C++ 关键特性。

学习本章前，读者应当已经掌握：

• cpp/概述与现代标准：C++11/14/17/20 的标准演进
• cpp/基础语法：变量声明、作用域、控制流
• cpp/数据类型详解：基本类型、模板基础
• cpp/指针：裸指针的内存模型与算术运算
• cpp/右值引用与移动语义：std::move、移动构造、值类别

掌握本章后，读者将能够阅读 cpp/RAII资源管理、cpp/模板元编程、cpp/多线程编程 等高级主题，并具备在生产代码中正确选择与组合智能指针的能力。

1.2 学习目标

本章遵循 Bloom 分类法，按认知层级递进组织学习目标：

1. 记忆（Remember）：复述 unique_ptr、shared_ptr、weak_ptr 三种智能指针的所有权语义差异与引用计数状态机模型，识别 make_unique、make_shared、enable_shared_from_this 等核心 API。
2. 理解（Understand）：解释 RAII（Resource Acquisition Is Initialization，Bjarne Stroustrup 于 1980s 提出，“资源获取即初始化”）原则与 C++ 异常安全机制在智能指针设计中的形式化表达。
3. 应用（Apply）：使用 make_unique/make_shared 工厂函数构建异常安全的资源管理代码，编写自定义删除器（custom deleter）管理非内存资源。
4. 分析（Analyze）：对比三种智能指针的所有权（ownership，借用日常语义”负责管理某资源生命周期”的责任归属）语义，分析循环引用导致内存泄漏的代数性质与 weak_ptr 破解环路的数学论证。
5. 评估（Evaluate）：评估不同智能指针在多线程、ABI 稳定性、性能开销场景下的取舍，选择合适的所有权策略。
6. 创造（Create）：设计 Pimpl、工厂、依赖注入、对象池等基于智能指针的生产级架构，并保证异常安全与线程安全。

1.3 阅读建议

• 零基础读者：先通读第 2、3、4 章建立直观认识，再回看第 5、6 章深入引用计数；
• 有 C++03 经验读者：重点关注第 2 章历史动机与第 4-7 章现代 API；
• 进阶读者：直接研读第 8-12 章的工程实践与开源项目案例。

第 2 章 历史动机与演进

2.1 1980s：RAII 范式的诞生

C++ 的资源管理哲学根植于 Bjarne Stroustrup 在 1980s 提出的 RAII 原则。RAII 的核心思想是：将资源的获取绑定到对象的构造，资源的释放绑定到对象的析构。当对象离开作用域时，析构函数由编译器自动调用，无论退出路径是正常返回、提前 return 还是异常栈展开。

RAII 的动机来自 C 语言手动管理资源的痛点。考虑 C 风格的资源管理：

/* C 风格：每条错误路径都必须显式释放资源 */
int process(const char* path) {
    FILE* f = fopen(path, "r");
    if (!f) return -1;

    Buffer* buf = allocate_buffer(1024);
    if (!buf) {
        fclose(f);
        return -2;
    }

    if (read_data(f, buf) < 0) {
        free_buffer(buf);
        fclose(f);
        return -3;
    }

    /* ... 业务逻辑 ... */
    if (error) {
        free_buffer(buf);   /* 必须重复释放 */
        fclose(f);
        return -4;
    }

    free_buffer(buf);
    fclose(f);
    return 0;
}

每条错误路径都需要重复释放资源，极易遗漏。RAII 通过析构函数自动释放，从根本上消除这类问题：

#include <memory>
#include <cstdio>
#include <iostream>

// RAII 封装 FILE*
class FileGuard {
    FILE* fp_;
public:
    explicit FileGuard(const char* path, const char* mode)
        : fp_(std::fopen(path, mode)) {
        if (!fp_) throw std::runtime_error("无法打开文件");
    }
    ~FileGuard() { if (fp_) std::fclose(fp_); }
    FileGuard(const FileGuard&) = delete;
    FileGuard& operator=(const FileGuard&) = delete;
    FILE* get() const { return fp_; }
};

int main() {
    FileGuard f("test.txt", "w");
    std::fprintf(f.get(), "hello RAII\n");
    // 离开作用域自动 fclose，即使抛异常也安全
    return 0;
}

2.2 1990s：Boehm GC 与 auto_ptr 的折中

1990s 早期，C++ 社区曾就”是否引入垃圾回收”展开激烈讨论。Hans-J. Boehm 于 1993 年实现了保守式垃圾回收器（Boehm GC），但 Stroustrup 坚持认为：C++ 应保留确定性的资源管理（deterministic resource management），而非引入非确定性的 GC。这一决策最终体现为：

• 1995 年 C++95 标准引入 std::auto_ptr，提供独占所有权的智能指针；
• 1998 年 C++98 标准正式将 auto_ptr 纳入 <memory> 头；
• 2011 年 C++11 引入 unique_ptr、shared_ptr、weak_ptr；
• 2014 年 C++14 引入 std::make_unique（填补 C++11 的遗漏）；
• 2017 年 C++17 正式移除 auto_ptr，引入 shared_ptr<T[]> 数组特化。

2.3 1998：auto_ptr 的设计缺陷

std::auto_ptr 的核心缺陷在于复制构造隐式转移所有权：

#include <iostream>
#include <memory>

// 模拟 auto_ptr 行为（C++17 已移除，这里用伪代码演示）
template<typename T>
class AutoPtr {
    T* ptr_;
public:
    explicit AutoPtr(T* p = nullptr) : ptr_(p) {}
    // 破坏性复制：源对象变空
    AutoPtr(AutoPtr& other) noexcept : ptr_(other.release()) {}
    AutoPtr& operator=(AutoPtr& other) noexcept {
        if (this != &other) { delete ptr_; ptr_ = other.release(); }
        return *this;
    }
    ~AutoPtr() { delete ptr_; }
    T* release() { T* p = ptr_; ptr_ = nullptr; return p; }
    T& operator*() const { return *ptr_; }
    T* operator->() const { return ptr_; }
};

int main() {
    AutoPtr<int> p(new int(42));
    AutoPtr<int> q = p;        // 复制！但 p 已为空
    // *p = 100;               // UB：p 已为空
    std::cout << *q << "\n";   // 输出: 42
    return 0;
}

这一行为与值语义直觉严重冲突，更致命的是不满足 STL 容器的 CopyConstructible 要求：

#include <vector>
#include <algorithm>
#include <memory>

// 假设 auto_ptr 仍可用
void buggy() {
    std::vector<std::auto_ptr<int>> v;
    v.push_back(std::auto_ptr<int>(new int(1)));
    v.push_back(std::auto_ptr<int>(new int(2)));

    // sort 内部通过复制实现元素交换
    // 复制后源变空，元素悄然丢失
    std::sort(v.begin(), v.end(),
              [](const std::auto_ptr<int>& a, const std::auto_ptr<int>& b) {
                  return *a < *b;
              });
    // v 中部分元素可能已为空指针
}

2.4 2001：Boost 智能指针的影响

2001 年 Boost 1.21.0 引入了 boost::shared_ptr、boost::weak_ptr、boost::intrusive_ptr，由 Peter Dimov 等人设计。Boost 智能指针成为 C++11 标准智能指针的直接蓝本：

Andrei Alexandrescu 在 2001 年出版的《Modern C++ Design》中提出了基于 policy-based design 的 Loki::SmartPtr，允许通过模板参数组合所有权策略（deep copy、reference counting、COM intrusive 等），深刻影响了后续智能指针的设计哲学。

2.5 2011：C++11 的革命性引入

C++11 是智能指针演进史上的里程碑，引入了完整的现代智能指针体系：

C++11 同时废弃 auto_ptr（标记为 deprecated），C++17 正式将其从标准移除。

2.6 2014：make_unique 的补完

C++11 遗漏了 std::make_unique，导致代码风格不对称：

auto sp = std::make_shared<T>(args);  // C++11 OK
// auto up = std::make_unique<T>(args);  // C++11 不存在！
std::unique_ptr<T> up(new T(args));   // C++11 只能这样写

C++14（N3471 提案）补完 make_unique，并支持数组形式 make_unique<T[]>(n)。

2.7 2017 与 2023：精细化与稳定

C++17 关键改进：

• 移除 auto_ptr；
• 引入 shared_ptr<T[]> 数组特化（shared_ptr 终于原生支持数组）；
• make_shared 支持对齐分配（make_shared<T> 与 alignas(T) 兼容）；
• weak_ptr::lock 算法优化。

C++20 进一步：

• 引入 std::bit_cast，便于安全类型转换；
• concepts 可约束智能指针模板参数（如 std::movable<T> 约束 unique_ptr 的元素）；
• consteval 与 constexpr 增强，部分智能指针操作可在编译期执行。

C++23 引入 std::out_ptr 与 std::inout_ptr（用于与 C 风格 out-parameter API 互操作）：

#include <memory>
#include <cstdio>

// C++23：std::out_ptr 简化 C API 互操作
void c_api(FILE** out);

int main() {
    auto fp = std::make_unique<std::FILE, decltype(&std::fclose)>(nullptr, &std::fclose);
    c_api(std::out_ptr(fp));   // C++23：自动管理 out 参数
    return 0;
}

第 3 章 形式化定义与所有权模型

3.1 所有权的形式化定义

为了消除自然语言的歧义，本节以数学形式化方式定义智能指针的语义。该形式化对应 C++ 标准 [smartptr] 子条款。

设 $\mathcal{O}$ 为对象集合，$\mathcal{P}(\mathcal{O})$ 为 $\mathcal{O}$ 的幂集。设 $S : \mathcal{O} \to \mathbb{N}$ 为强引用计数函数（strong count），$W : \mathcal{O} \to \mathbb{N}$ 为弱引用计数函数（weak count）。

定义 3.1（所有权语义）：所有权关系 $\text{Owns} \subseteq \mathcal{O} \times \mathcal{O}$ 满足：

• 独占所有权（unique_ptr）：$\forall o \in \mathcal{O}, |\{ p \mid \text{Owns}(p, o) \}| \leq 1$
• 共享所有权（shared_ptr）：$\forall o \in \mathcal{O}, |\{ p \mid \text{Owns}(p, o) \}| = S(o)$
• 观察所有权（weak_ptr）：$\text{Owns}(p, o) \implies S(o) > 0$，且 $p$ 不增加 $S(o)$

定义 3.2（unique_ptr）：类型为 std::unique_ptr<T, D> 的智能指针 $u$ 是一个四元组 $(o, T, D, \text{null})$，其中 $o \in \mathcal{O} \cup \{\bot\}$ 为托管对象或空，$T \in \mathcal{T}$ 为所指类型，$D$ 为删除器类型。形式上：

$u : \text{unique\_ptr}\langle T, D \rangle \triangleq (o, T, D), \quad o \in \mathcal{O} \cup \{\bot\}$

不变量 U1（独占性）：在任意时刻，对任意 $o \in \mathcal{O}$，至多存在一个 unique_ptr $u$ 满足 $u.o = o$。

不变量 U2（移动转移）：std::move(u) 将 $u$ 转换为右值，移动构造/赋值后源对象 $u.o \leftarrow \bot$，目标对象获得原 $o$。

定义 3.3（shared_ptr）：类型为 std::shared_ptr<T> 的智能指针 $s$ 是一个三元组 $(o, T, c)$，其中 $c$ 为指向控制块（control block，shared_ptr 内部管理引用计数的元数据结构，包含 strong count 与 weak count 两个原子计数器）的指针。

$s : \text{shared\_ptr}\langle T \rangle \triangleq (o, T, c), \quad c = (\text{sc}, \text{wc}, \text{del}, \text{alloc})$

其中 $\text{sc} \in \mathbb{N}^+$ 为强引用计数，$\text{wc} \in \mathbb{N}^+$ 为弱引用计数，$\text{del}$ 为删除器，$\text{alloc}$ 为分配器。

不变量 S1（强引用一致性）：对任意 $o \in \mathcal{O}$ 与对应控制块 $c$，$c.\text{sc} = |\{ s \mid s.o = o \}|$。

不变量 S2（弱引用独立性）：$\text{wc} \geq 1$ 当且仅当存在 weak_ptr 引用 $c$；$\text{wc}$ 不受 shared_ptr 拷贝/析构影响。

定义 3.4（weak_ptr）：类型为 std::weak_ptr<T> 的智能指针 $w$ 是一个二元组 $(c, T)$，仅持有控制块指针，不持有对象指针。

$w : \text{weak\_ptr}\langle T \rangle \triangleq (c, T)$

不变量 W1（不增加强引用）：构造 $w$ 时 $c.\text{wc} \mathrel{+}= 1$，但 $c.\text{sc}$ 不变。

不变量 W2（控制块存活）：$c.\text{sc} > 0 \lor c.\text{wc} > 0 \implies c$ 存活；仅当两者均为 0 时控制块被释放。

3.2 引用计数的状态机模型

shared_ptr 的引用计数构成一个有限状态机：

stateDiagram-v2
    [*] --> Constructed: make_shared/sc=1
    Constructed --> Shared: copy/sc+1
    Shared --> Constructed: reset/sc-1
    Constructed --> ObjectDestroyed: sc=0/调用析构
    ObjectDestroyed --> BlockAlive: wc>0
    ObjectDestroyed --> [*]: wc=0/释放控制块
    BlockAlive --> [*]: weak_ptr全部析构/wc=0
    note right of ObjectDestroyed
        对象析构但控制块存活
        weak_ptr::lock 返回空
    end note

状态转移规则：

• $\text{Constructed} \xrightarrow{\text{copy}} \text{Shared}$：shared_ptr 拷贝构造，$\text{sc} \mathrel{+}= 1$
• $\text{Shared} \xrightarrow{\text{reset}} \text{Constructed}$：shared_ptr reset/析构，$\text{sc} \mathrel{-}= 1$
• $\text{Constructed} \xrightarrow{\text{sc}=0} \text{ObjectDestroyed}$：调用对象析构函数
• $\text{ObjectDestroyed} \xrightarrow{\text{wc}=0} [*]$：释放控制块
• $\text{ObjectDestroyed} \xrightarrow{\text{wc}>0} \text{BlockAlive}$：等待所有 weak_ptr 释放

3.3 引用计数的代数性质

设 $s_1, s_2, \dots, s_n$ 为指向同一对象 $o$ 的 shared_ptr 集合，记 $|S| = n$。引用计数满足以下代数性质：

性质 RC1（计数一致性）：$c.\text{sc} = n$ 在任意时刻成立。

性质 RC2（拷贝原子性）：$s_i \to s_j$ 的拷贝操作等价于原子执行 $\text{sc} \mathrel{+}= 1$。

性质 RC3（析构顺序无关性）：$s_1, \dots, s_n$ 的析构顺序不影响 $\text{sc}$ 的最终值（0）。

性质 RC4（线程安全）：对 $\text{sc}$ 的并发读写满足顺序一致性（sequentially consistent）语义，但对象本身的访问需用户自行同步。

3.4 所有权不变量与对象生命周期

C++ 标准 [basic.life] 定义对象的生命周期为”构造完成到析构开始”的时间段。智能指针通过所有权不变量保证：

定理 3.1（生命周期保证）：若对象 $o$ 被 unique_ptr $u$ 托管，则 $o$ 的生命周期 $\supseteq u$ 的生命周期。

证明：由不变量 U1，$u$ 是唯一持有 $o$ 的智能指针。$u$ 析构时调用删除器 $D(o)$，触发 $o$ 的析构。在 $u$ 存活期间，$o$ 必然存活。$\square$

定理 3.2（共享生命周期）：若对象 $o$ 被 $n$ 个 shared_ptr 共享，则 $o$ 的生命周期 $\supseteq \bigcup_{i=1}^{n} \text{lifetime}(s_i)$，且 $\subseteq \bigcup_{i=1}^{n} \text{lifetime}(s_i) \cup \{\text{析构延迟}\}$。

证明：由不变量 S1，$\text{sc} = n$。每个 $s_i$ 析构时 $\text{sc} \mathrel{-}= 1$。当 $\text{sc} = 0$ 时调用 $o$ 的析构函数。因此 $o$ 在所有 $s_i$ 存活期间必然存活，且在最后一个 $s_i$ 析构时立即析构（确定性析构）。$\square$

第 4 章 unique_ptr：独占所有权

4.1 基础用法

std::unique_ptr 是零开销抽象的智能指针，独占管理对象生命周期。它不可拷贝，仅可移动：

#include <memory>
#include <iostream>

class Widget {
public:
    Widget()  { std::cout << "Widget 构造\n"; }
    ~Widget() { std::cout << "Widget 析构\n"; }
    void use() { std::cout << "Widget 使用\n"; }
};

int main() {
    // 推荐：make_unique 异常安全
    auto p = std::make_unique<Widget>();
    p->use();
    std::cout << "地址: " << p.get() << "\n";
    // 输出:
    // Widget 构造
    // Widget 使用
    // 地址: 0x...
    // Widget 析构
    return 0;
}

4.2 移动语义

unique_ptr 的拷贝构造与拷贝赋值被声明为 = delete，所有权转移必须通过 std::move 显式完成：

#include <memory>
#include <iostream>

int main() {
    auto p = std::make_unique<int>(42);
    // auto q = p;            // 编译错误：拷贝构造被删除
    auto q = std::move(p);    // 移动构造：p 变空，q 获得所有权

    std::cout << "p 是否为空: " << (p == nullptr) << "\n";  // 输出: 1
    std::cout << "*q = " << *q << "\n";                     // 输出: 42
    return 0;
}

4.3 所有权转移状态机

stateDiagram-v2
    [*] --> Owned_by_P: make_unique
    Owned_by_P --> Owned_by_Q: std::move(p)
    note right of Owned_by_Q
        p.o = ⊥ (空)
        q.o = 原 p.o
    end note
    Owned_by_Q --> [*]: q 析构
    Owned_by_P --> [*]: p 析构（未转移）

4.4 release 与 reset

#include <memory>
#include <iostream>

int main() {
    auto p = std::make_unique<int>(42);

    // release：放弃所有权，返回裸指针
    int* raw = p.release();
    std::cout << "p 是否为空: " << (p == nullptr) << "\n";  // 输出: 1
    std::cout << "*raw = " << *raw << "\n";                 // 输出: 42
    delete raw;   // 调用者负责释放

    // reset：替换托管对象
    auto q = std::make_unique<int>(1);
    q.reset(new int(100));   // 释放旧对象，接管新对象
    std::cout << "*q = " << *q << "\n";                     // 输出: 100
    q.reset();               // 释放对象，q 变空
    std::cout << "q 是否为空: " << (q == nullptr) << "\n";  // 输出: 1
    return 0;
}

4.5 数组特化

unique_ptr<T[]> 是数组特化，提供 operator[] 但不提供 operator* 与 operator->：

#include <memory>
#include <iostream>

int main() {
    auto arr = std::make_unique<int[]>(5);
    for (int i = 0; i < 5; ++i) {
        arr[i] = i * i;
    }
    for (int i = 0; i < 5; ++i) {
        std::cout << arr[i] << ' ';   // 输出: 0 1 4 9 16
    }
    std::cout << "\n";
    // *arr;        // 编译错误：数组特化不提供 operator*
    // arr->...;    // 编译错误：数组特化不提供 operator->
    return 0;
}

注意：现代 C++ 推荐使用 std::vector 或 std::array 替代 unique_ptr<T[]>，因为标准容器提供更完整的接口（size、迭代器、范围检查等）。

4.6 自定义删除器

unique_ptr 的删除器作为类型参数的一部分，无运行时开销（编译期绑定）：

#include <memory>
#include <cstdio>
#include <iostream>

// 使用 lambda 作为删除器
auto file_closer = [](FILE* f) {
    if (f) {
        std::fclose(f);
        std::cout << "文件已关闭\n";
    }
};

using UniqueFile = std::unique_ptr<FILE, decltype(file_closer)>;

UniqueFile openFile(const char* path, const char* mode) {
    FILE* f = std::fopen(path, mode);
    if (!f) throw std::runtime_error("无法打开文件");
    return UniqueFile(f, file_closer);
}

int main() {
    auto f = openFile("/tmp/test.txt", "w");
    std::fprintf(f.get(), "hello\n");
    // 离开作用域自动调用 file_closer
    // 输出: 文件已关闭
    return 0;
}

#include <memory>
#include <cstdlib>
#include <iostream>

// 函数指针删除器：unique_ptr<T, void(*)(T*)>
std::unique_ptr<int, void(*)(int*)> make_allocated(int v) {
    return std::unique_ptr<int, void(*)(int*)>(new int(v), [](int* p) {
        std::cout << "delete int\n";
        delete p;
    });
}

// 仿函数删除器（无状态）：零开销
struct FreeDeleter {
    void operator()(void* p) const {
        std::free(p);
        std::cout << "free\n";
    }
};

int main() {
    auto p = make_allocated(42);
    std::cout << *p << "\n";   // 输出: 42

    std::unique_ptr<int, FreeDeleter> fp(static_cast<int*>(std::malloc(sizeof(int))));
    *fp = 100;
    std::cout << *fp << "\n";  // 输出: 100
    // 输出: free
    return 0;
}

4.7 大小开销

unique_ptr<T> 的大小通常等于裸指针（1 个字）：

#include <memory>
#include <iostream>

int main() {
    std::cout << "sizeof(int*) = " << sizeof(int*) << "\n";
    std::cout << "sizeof(unique_ptr<int>) = "
              << sizeof(std::unique_ptr<int>) << "\n";
    // 无状态删除器时大小相同
    std::cout << "sizeof(unique_ptr<int, void(*)(int*)>) = "
              << sizeof(std::unique_ptr<int, void(*)(int*)>) << "\n";
    // 函数指针删除器多 1 个字
    return 0;
}

输出（64 位 Linux）：

sizeof(int*) = 8
sizeof(unique_ptr<int>) = 8
sizeof(unique_ptr<int, void(*)(int*)>) = 16

4.8 转换为 shared_ptr

unique_ptr 可隐式转换为 shared_ptr，反向不可：

#include <memory>
#include <iostream>

int main() {
    std::unique_ptr<int> up = std::make_unique<int>(42);
    std::shared_ptr<int> sp = std::move(up);   // 隐式转换

    std::cout << "up 是否为空: " << (up == nullptr) << "\n";  // 输出: 1
    std::cout << "*sp = " << *sp << "\n";                     // 输出: 42
    std::cout << "sp use_count = " << sp.use_count() << "\n"; // 输出: 1

    // std::unique_ptr<int> up2 = sp;   // 编译错误：shared_ptr 不能转 unique_ptr
    return 0;
}

4.9 工厂函数返回 unique_ptr

工厂函数返回 unique_ptr 是表达”调用者获得所有权”的最佳方式：

#include <memory>
#include <stdexcept>
#include <iostream>

class Shape {
public:
    virtual ~Shape() = default;
    virtual double area() const = 0;
    virtual void print() const = 0;
};

class Circle : public Shape {
    double r_;
public:
    explicit Circle(double r) : r_(r) {}
    double area() const override { return 3.14159 * r_ * r_; }
    void print() const override {
        std::cout << "Circle r=" << r_ << " area=" << area() << "\n";
    }
};

class Rectangle : public Shape {
    double w_, h_;
public:
    Rectangle(double w, double h) : w_(w), h_(h) {}
    double area() const override { return w_ * h_; }
    void print() const override {
        std::cout << "Rectangle " << w_ << "x" << h_
                  << " area=" << area() << "\n";
    }
};

// 工厂函数：返回 unique_ptr 表达所有权转移
std::unique_ptr<Shape> createShape(const std::string& type,
                                    double a, double b = 0) {
    if (type == "circle")    return std::make_unique<Circle>(a);
    if (type == "rectangle") return std::make_unique<Rectangle>(a, b);
    throw std::invalid_argument("未知形状: " + type);
}

int main() {
    auto s1 = createShape("circle", 2);
    auto s2 = createShape("rectangle", 3, 4);
    s1->print();   // 输出: Circle r=2 area=12.5664
    s2->print();   // 输出: Rectangle 3x4 area=12
    return 0;
}

第 5 章 shared_ptr：共享所有权

5.1 基础用法

std::shared_ptr 通过引用计数（reference counting，George Collins 于 1960 年在 IBM 论文中首次描述用于自动内存管理的引用计数技术）实现共享所有权：

#include <memory>
#include <iostream>

int main() {
    auto p1 = std::make_shared<int>(42);
    auto p2 = p1;    // 拷贝：引用计数 +1

    std::cout << "*p1 = " << *p1 << "\n";                     // 输出: 42
    std::cout << "use_count = " << p1.use_count() << "\n";    // 输出: 2

    p1.reset();
    std::cout << "p2 use_count = " << p2.use_count() << "\n"; // 输出: 1
    std::cout << "*p2 = " << *p2 << "\n";                     // 输出: 42
    return 0;
}

5.2 引用计数流转图

graph LR
    A[make_shared<br/>sc=1] -->|copy| B[sc=2]
    B -->|copy| C[sc=3]
    C -->|reset| B
    B -->|reset| A
    A -->|reset| D[sc=0<br/>析构对象]
    D --> E{wc=0?}
    E -->|是| F[释放控制块]
    E -->|否| G[控制块存活<br/>weak_ptr::lock 返回空]
    G -->|weak_ptr 全部析构| F
    style D fill:#f96,color:#000
    style F fill:#6c6,color:#fff
    style G fill:#ff9,color:#000

5.3 make_shared 的优势

make_shared 将对象本体与控制块合并为单次堆分配，相比 shared_ptr<T>(new T) 有三大优势：

#include <memory>
#include <iostream>

class Big {
public:
    Big()  { std::cout << "Big 构造\n"; }
    ~Big() { std::cout << "Big 析构\n"; }
    int data[1000];
};

int main() {
    // 方式 A：make_shared —— 单次分配
    auto a = std::make_shared<Big>();

    // 方式 B：new + shared_ptr —— 两次分配
    std::shared_ptr<Big> b(new Big());

    // 两者语义等价，但 A 性能更优
    return 0;
}

make_shared 的内存布局：

+-----------------------------------+
| 控制块 | Big 对象本体              |
+-----------------------------------+
^        ^
|        |
|        +-- shared_ptr 内部对象指针
+-- shared_ptr/weak_ptr 内部控制块指针

new 方式的内存布局：

+-------------+         +-------------+
| 控制块      |         | Big 对象    |
+-------------+         +-------------+
^                        ^
|                        |
+-- shared_ptr           +-- shared_ptr 内部对象指针
    内部控制块指针

优势 1：单次分配：减少一次 operator new 调用，提升性能。

优势 2：缓存局部性：对象与控制块在同一缓存行，减少 cache miss。

优势 3：异常安全：避免 f(shared_ptr<T>(new T), g()) 中 g() 抛异常导致的泄漏：

#include <memory>

void f(std::shared_ptr<int>, int);
int g();

// 风险：new T 与 g() 的求值顺序未指定
// 若 g() 先求值抛异常，new T 已分配但 shared_ptr 未构造，泄漏
void risky() {
    f(std::shared_ptr<int>(new int(42)), g());
}

// 安全：make_shared 内部分配与构造原子
void safe() {
    f(std::make_shared<int>(42), g());
}

5.4 make_shared 的劣势

make_shared 也有不适用场景：

#include <memory>

class Widget {
public:
    Widget(int, int) {}
    // 大对象 + 长期 weak_ptr 场景
};

// 场景 1：希望立即释放对象内存
// make_shared 的对象与控制块同块，weak_ptr 存活期间对象内存不释放
void case1() {
    auto sp = std::make_shared<Widget>(1, 2);
    std::weak_ptr<Widget> wp = sp;
    sp.reset();
    // 此时 Widget 已析构，但内存仍被控制块占用，直至 wp 析构
}

// 场景 2：自定义删除器（make_shared 不支持）
void case2() {
    // auto p = std::make_shared<FILE>(...);  // 无法传入 fclose
    std::shared_ptr<FILE> fp(std::fopen("a.txt", "r"),
                              std::fclose);
}

// 场景 3：类私有构造函数（make_shared 无法 friend）
class PrivateCtor {
    PrivateCtor(int) {}
    friend std::unique_ptr<PrivateCtor> std::make_unique<PrivateCtor>(int&&);
public:
    static std::shared_ptr<PrivateCtor> create(int v) {
        // make_shared 无法访问私有构造
        return std::shared_ptr<PrivateCtor>(new PrivateCtor(v));
    }
};

5.5 别名构造（Aliasing Constructor）

别名构造（aliasing constructor，C++11 引入的 shared_ptr<T>(shared_ptr<U>, T*) 构造形式，“aliasing” 指针别名，共享控制块但指向不同对象）允许创建指向成员但共享整个对象生命周期的 shared_ptr：

#include <memory>
#include <string>
#include <iostream>

struct Config {
    std::string host;
    int port;
    std::string database;
};

// 返回指向 config->host 的 shared_ptr，引用计数与 config 共享
std::shared_ptr<std::string> getHost(std::shared_ptr<Config> config) {
    return std::shared_ptr<std::string>(config, &config->host);
}

int main() {
    auto cfg = std::make_shared<Config>(Config{"localhost", 3306, "mydb"});
    auto host = getHost(cfg);

    cfg.reset();   // cfg 释放，但 host 仍持有
    std::cout << *host << "\n";   // 输出: localhost
    std::cout << "use_count = " << host.use_count() << "\n";  // 输出: 1
    // Config 对象存活至 host 析构
    return 0;
}

5.6 enable_shared_from_this

当对象被 shared_ptr 管理时，如何安全地获取指向自身的 shared_ptr？直接 shared_ptr<T>(this) 会触发 double-free：

#include <memory>
#include <iostream>

class Bad : public std::enable_shared_from_this<Bad> {
public:
    std::shared_ptr<Bad> getSelf() {
        // return std::shared_ptr<Bad>(this);  // 错误：double-free！
        return shared_from_this();              // 正确：共享控制块
    }
};

int main() {
    auto p = std::make_shared<Bad>();
    auto q = p->getSelf();
    std::cout << "use_count = " << p.use_count() << "\n";   // 输出: 2
    return 0;
}

enable_shared_from_this<T> 内部持有一个 weak_ptr<T>，在 shared_ptr 首次构造该对象时被初始化为指向 this 的 weak_ptr。shared_from_this() 调用 weak_ptr::lock() 返回 shared_ptr，与原 shared_ptr 共享控制块。

5.7 类型转换

shared_ptr 支持安全的派生类到基类转换：

#include <memory>
#include <iostream>

class Base {
public:
    virtual ~Base() = default;
    virtual void who() { std::cout << "Base\n"; }
};

class Derived : public Base {
public:
    void who() override { std::cout << "Derived\n"; }
};

int main() {
    std::shared_ptr<Derived> d = std::make_shared<Derived>();

    // 隐式向上转换
    std::shared_ptr<Base> b = d;   // 拷贝，引用计数共享
    std::cout << "use_count = " << b.use_count() << "\n";  // 输出: 2

    // 显式向下转换
    std::shared_ptr<Derived> d2 = std::static_pointer_cast<Derived>(b);
    std::cout << "use_count = " << b.use_count() << "\n";  // 输出: 3

    // dynamic_pointer_cast：失败返回空
    std::shared_ptr<Derived> d3 = std::dynamic_pointer_cast<Derived>(b);
    std::cout << "d3 是否为空: " << (d3 == nullptr) << "\n";  // 输出: 0

    // const_pointer_cast：去除 const
    std::shared_ptr<const Base> cb = b;
    std::shared_ptr<Base> nb = std::const_pointer_cast<Base>(cb);

    b->who();   // 输出: Derived
    return 0;
}

5.8 数组特化（C++17）

C++17 之前 shared_ptr 不原生支持数组，需要自定义删除器：

#include <memory>
#include <iostream>

int main() {
    // C++11/14：自定义删除器
    std::shared_ptr<int> oldWay(new int[10], std::default_delete<int[]>());
    // oldWay[0] = 1;   // 编译错误：shared_ptr<int> 无 operator[]

    // C++17：原生数组特化
    std::shared_ptr<int[]> arr = std::make_shared<int[]>(10);
    for (int i = 0; i < 10; ++i) arr[i] = i;
    std::cout << arr[5] << "\n";   // 输出: 5

    // C++20：make_shared 对齐版本
    // std::shared_ptr<int[]> arr2 = std::make_shared<int[]>(10, 42);  // C++20
    return 0;
}

5.9 线程安全性

shared_ptr 的线程安全遵循以下规则（对应标准 [util.smartptr.shared]）：

1. 引用计数操作线程安全：拷贝/析构 shared_ptr 是原子的；
2. 同一 shared_ptr 实例的读写不线程安全：多线程访问同一 shared_ptr 实例需同步；
3. 不同 shared_ptr 实例的访问线程安全：即使指向同一对象，不同实例可被不同线程访问；
4. 对象本身的访问不线程安全：通过 shared_ptr 访问对象需自行同步。

#include <memory>
#include <mutex>
#include <vector>
#include <iostream>

// 线程安全的共享数据容器
class ThreadSafeData {
    std::shared_ptr<const std::vector<int>> data_;
    mutable std::mutex mtx_;
public:
    ThreadSafeData() : data_(std::make_shared<const std::vector<int>>()) {}

    std::shared_ptr<const std::vector<int>> get() const {
        std::lock_guard<std::mutex> lk(mtx_);
        return data_;   // 返回拷贝，线程安全
    }

    void update(std::shared_ptr<const std::vector<int>> newData) {
        std::lock_guard<std::mutex> lk(mtx_);
        data_ = std::move(newData);
    }

    size_t size() const {
        std::lock_guard<std::mutex> lk(mtx_);
        return data_->size();
    }
};

int main() {
    ThreadSafeData tsd;
    auto v = std::make_shared<const std::vector<int>>(std::vector<int>{1, 2, 3});
    tsd.update(v);
    std::cout << "size = " << tsd.size() << "\n";   // 输出: 3
    return 0;
}

5.10 控制块创建时机

控制块在以下时机创建：

1. 调用 make_shared；
2. 从 unique_ptr 构造 shared_ptr；
3. 用裸指针构造 shared_ptr。

陷阱：同一裸指针构造两个 shared_ptr 会创建两个控制块，导致 double-free：

#include <memory>

int main() {
    int* raw = new int(42);
    std::shared_ptr<int> p1(raw);
    // std::shared_ptr<int> p2(raw);   // UB：两个独立控制块，double-free
    return 0;
}

第 6 章 weak_ptr：打破循环引用

6.1 基础用法

std::weak_ptr 是 shared_ptr 的”观察者”，不增加强引用计数：

#include <memory>
#include <iostream>

int main() {
    auto sp = std::make_shared<int>(42);
    std::weak_ptr<int> wp = sp;   // 不增加 strong count

    std::cout << "sp use_count = " << sp.use_count() << "\n";   // 输出: 1
    std::cout << "wp use_count = " << wp.use_count() << "\n";   // 输出: 1
    std::cout << "wp expired = " << wp.expired() << "\n";       // 输出: 0

    // 安全访问：lock() 原子升级为 shared_ptr
    if (auto locked = wp.lock()) {
        std::cout << "*locked = " << *locked << "\n";           // 输出: 42
    }

    sp.reset();
    std::cout << "wp expired = " << wp.expired() << "\n";       // 输出: 1
    auto locked = wp.lock();
    std::cout << "locked 是否为空: " << (locked == nullptr) << "\n";  // 输出: 1
    return 0;
}

6.2 循环引用的形式化分析

设两个对象 $A$ 与 $B$，各自持有一个 shared_ptr 指向对方：

$\text{strong}(A) = 1 + \text{shared\_ptr}\langle A \rangle \text{ in } B$ $\text{strong}(B) = 1 + \text{shared\_ptr}\langle B \rangle \text{ in } A$

当外部 shared_ptr 离开作用域后：

$\text{strong}(A) = \text{shared\_ptr}\langle A \rangle \text{ in } B = 1$ $\text{strong}(B) = \text{shared\_ptr}\langle B \rangle \text{ in } A = 1$

两者相互维持非零，构成不动点，无法归零，导致内存泄漏。

#include <memory>
#include <iostream>

struct Node {
    std::shared_ptr<Node> next;
    std::shared_ptr<Node> prev;
    ~Node() { std::cout << "Node 析构\n"; }
};

int main() {
    auto a = std::make_shared<Node>();
    auto b = std::make_shared<Node>();
    a->next = b;       // strong(b) += 1
    b->prev = a;       // strong(a) += 1
    std::cout << "a use_count = " << a.use_count() << "\n";  // 输出: 2
    std::cout << "b use_count = " << b.use_count() << "\n";  // 输出: 2
    return 0;
    // a、b 离开作用域：strong(a)=1, strong(b)=1，永不析构！
    // 无 "Node 析构" 输出
}

6.3 weak_ptr 破解循环引用

将环路一侧改为 weak_ptr 即可打破不动点：

graph LR
    A[a shared_ptr<br/>strong=1] -->|next: shared_ptr| B[b]
    B -->|prev: weak_ptr<br/>不增加 strong| A
    style A fill:#6c6,color:#fff
    style B fill:#69f,color:#fff

#include <memory>
#include <iostream>

struct Node {
    std::shared_ptr<Node> next;   // 强引用：拥有后继
    std::weak_ptr<Node>   prev;   // 弱引用：仅观察前驱
    ~Node() { std::cout << "Node 析构\n"; }
};

int main() {
    auto a = std::make_shared<Node>();
    auto b = std::make_shared<Node>();
    a->next = b;       // strong(b) = 2
    b->prev = a;       // weak count +1，strong(a) 不变 = 1

    std::cout << "a use_count = " << a.use_count() << "\n";  // 输出: 1
    std::cout << "b use_count = " << b.use_count() << "\n";  // 输出: 2
    return 0;
    // a 离开作用域：strong(a)=0，a 析构
    // a 析构 → a->next 析构 → strong(b)=1
    // b 离开作用域：strong(b)=0，b 析构
    // 输出: Node 析构 (两次)
}

6.4 weak_ptr::lock 的原子性

weak_ptr::lock() 是原子操作，避免 TOCTOU（Time-of-Check-to-Time-of-Use）竞态：

#include <memory>
#include <iostream>

// 错误模式：expired() 与构造 shared_ptr 之间存在窗口
void risky(std::weak_ptr<int>& wp) {
    if (!wp.expired()) {
        // 此时另一线程可能 reset，wp 已过期
        // std::shared_ptr<int> sp(wp);   // 抛 bad_weak_ptr
    }
}

// 正确模式：lock() 原子地"检查 + 升级"
void safe(std::weak_ptr<int>& wp) {
    if (auto sp = wp.lock()) {
        // sp 持有对象，安全使用
        std::cout << *sp << "\n";
    } else {
        std::cout << "对象已析构\n";
    }
}

6.5 缓存模式

weak_ptr 是实现缓存（cache）的理想工具：缓存持有 weak_ptr，对象生命周期由外部 shared_ptr 决定：

#include <memory>
#include <unordered_map>
#include <mutex>
#include <iostream>

class ExpensiveResource {
public:
    ExpensiveResource(int id) : id_(id) {
        std::cout << "构造资源 " << id_ << "\n";
    }
    ~ExpensiveResource() {
        std::cout << "析构资源 " << id_ << "\n";
    }
    int id_;
};

class ResourceCache {
    std::unordered_map<int, std::weak_ptr<ExpensiveResource>> cache_;
    mutable std::mutex mtx_;
public:
    std::shared_ptr<ExpensiveResource> get(int id) {
        std::lock_guard<std::mutex> lk(mtx_);
        auto it = cache_.find(id);
        if (it != cache_.end()) {
            if (auto sp = it->second.lock()) {
                std::cout << "缓存命中 " << id << "\n";
                return sp;
            }
        }
        std::cout << "缓存未命中 " << id << "\n";
        auto sp = std::make_shared<ExpensiveResource>(id);
        cache_[id] = sp;
        return sp;
    }
};

int main() {
    ResourceCache cache;
    {
        auto r1 = cache.get(1);   // 输出: 缓存未命中 1 / 构造资源 1
        auto r2 = cache.get(1);   // 输出: 缓存命中 1
    }   // r1、r2 析构，资源 1 析构
    auto r3 = cache.get(1);       // 输出: 缓存未命中 1 / 构造资源 1
    return 0;
}

6.6 观察者模式

观察者模式中，被观察对象（subject）不应持有观察者的强引用：

#include <memory>
#include <vector>
#include <algorithm>
#include <iostream>

class Observer {
public:
    virtual ~Observer() = default;
    virtual void onEvent(int) = 0;
};

class Subject {
    std::vector<std::weak_ptr<Observer>> observers_;
public:
    void subscribe(std::shared_ptr<Observer> o) {
        observers_.push_back(o);
    }

    void notify(int event) {
        // 清理过期观察者，并通知存活观察者
        observers_.erase(
            std::remove_if(observers_.begin(), observers_.end(),
                           [](const std::weak_ptr<Observer>& w) {
                               return w.expired();
                           }),
            observers_.end());

        for (auto& w : observers_) {
            if (auto sp = w.lock()) {
                sp->onEvent(event);
            }
        }
    }
};

class ConcreteObserver : public Observer {
    int id_;
public:
    explicit ConcreteObserver(int id) : id_(id) {}
    void onEvent(int e) override {
        std::cout << "Observer " << id_ << " 收到事件 " << e << "\n";
    }
};

int main() {
    Subject subject;
    auto o1 = std::make_shared<ConcreteObserver>(1);
    auto o2 = std::make_shared<ConcreteObserver>(2);
    subject.subscribe(o1);
    subject.subscribe(o2);

    subject.notify(42);
    // 输出:
    // Observer 1 收到事件 42
    // Observer 2 收到事件 42

    o1.reset();
    subject.notify(100);
    // 输出: Observer 2 收到事件 100（o1 已析构，自动跳过）
    return 0;
}

6.7 异步回调中的安全引用

异步回调（如 detach 线程、定时器）中，捕获 shared_ptr 延长对象生命周期，捕获 weak_ptr 检查存活：

#include <memory>
#include <thread>
#include <chrono>
#include <iostream>

class Service : public std::enable_shared_from_this<Service> {
public:
    void startAsync() {
        // 延长生命周期模式：捕获 shared_ptr
        auto self = shared_from_this();
        std::thread([self]() {
            std::this_thread::sleep_for(std::chrono::milliseconds(10));
            self->processResult();
        }).detach();
    }

    // 仅检查存活模式：捕获 weak_ptr
    void startCheckOnly() {
        std::weak_ptr<Service> weak = shared_from_this();
        std::thread([weak]() {
            std::this_thread::sleep_for(std::chrono::milliseconds(50));
            if (auto sp = weak.lock()) {
                sp->processResult();
            } else {
                std::cout << "Service 已析构，跳过\n";
            }
        }).detach();
    }

    void processResult() { std::cout << "处理结果\n"; }
};

int main() {
    {
        auto svc = std::make_shared<Service>();
        svc->startAsync();
        svc->startCheckOnly();
    }   // svc 析构，但 startAsync 的线程仍持有 self
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
    // 输出:
    // 处理结果（来自 startAsync）
    // Service 已析构，跳过（来自 startCheckOnly）
    return 0;
}

第 7 章 make_unique 与 make_shared 的异常安全

7.1 异常安全的数学论证

考虑函数调用 f(std::shared_ptr<T>(new T), g())。C++17 前的求值顺序未完全指定：

1. new T 分配内存并构造对象；
2. g() 求值；
3. shared_ptr 构造。

若编译器选择顺序 new T → g() → shared_ptr 构造，且 g() 抛异常，则 new T 已分配但 shared_ptr 未构造，内存泄漏。

C++17 修订了求值顺序，但 make_shared 仍是更安全的选择：

#include <memory>

void f(std::shared_ptr<int>, int);
int g();   // 可能抛异常

// 风险路径（C++17 前可能泄漏）
void risky() {
    f(std::shared_ptr<int>(new int(42)), g());
}

// 安全路径（make_shared 单次原子分配）
void safe() {
    f(std::make_shared<int>(42), g());
}

7.2 make_unique 的实现剖析

C++14 标准库的 make_unique 实现简化版：

#include <memory>
#include <type_traits>

// C++14 N3471 提案的简化实现
template<typename T, typename... Args>
std::unique_ptr<T> make_unique(Args&&... args) {
    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}

// 数组特化
template<typename T>
std::unique_ptr<T[]> make_unique(size_t n) {
    return std::unique_ptr<T[]>(new std::remove_extent_t<T>[n]());
}

7.3 make_shared 的内存布局优化

make_shared 的典型实现使用单次 operator new 分配”控制块 + 对象”的合并内存：

// 简化伪代码
template<typename T, typename... Args>
std::shared_ptr<T> make_shared(Args&&... args) {
    // 单次分配，包含控制块与 T 对象
    auto* block = static_cast<ControlBlock<T>*>(
        ::operator new(sizeof(ControlBlock<T>)));
    new (&block->storage) T(std::forward<Args>(args)...);
    new (&block->ctrl) ControlBlock();
    return std::shared_ptr<T>(&block->storage, &block->ctrl);
}

控制块典型结构：

+---------------------------+
| vptr (虚函数表指针)         |
| strong count (atomic)     |
| weak count (atomic)       |
| deleter (类型擦除)         |
| allocator (类型擦除)       |
+---------------------------+
| T 对象存储                 |
+---------------------------+

7.4 性能对比

#include <memory>
#include <chrono>
#include <iostream>

class Widget {
    int data_[64];
public:
    Widget() { data_[0] = 42; }
};

int main() {
    const int N = 1000000;

    auto t1 = std::chrono::high_resolution_clock::now();
    for (int i = 0; i < N; ++i) {
        auto sp = std::make_shared<Widget>();
    }
    auto t2 = std::chrono::high_resolution_clock::now();

    auto t3 = std::chrono::high_resolution_clock::now();
    for (int i = 0; i < N; ++i) {
        std::shared_ptr<Widget> sp(new Widget());
    }
    auto t4 = std::chrono::high_resolution_clock::now();

    auto make_dur = std::chrono::duration_cast<std::chrono::milliseconds>(t2 - t1);
    auto new_dur  = std::chrono::duration_cast<std::chrono::milliseconds>(t4 - t3);
    std::cout << "make_shared: " << make_dur.count() << " ms\n";
    std::cout << "new + shared_ptr: " << new_dur.count() << " ms\n";
    // 输出（典型，依机器而异）:
    // make_shared: 38 ms
    // new + shared_ptr: 76 ms
    return 0;
}

第 8 章 自定义删除器与类型擦除

8.1 unique_ptr 的删除器作为类型参数

unique_ptr<T, D> 的删除器 $D$ 是类型的一部分，无运行时多态开销：

#include <memory>
#include <cstdio>
#include <cstdlib>
#include <iostream>

// 不同删除器 → 不同类型
using UniqueInt    = std::unique_ptr<int>;
using UniqueIntNew = std::unique_ptr<int, void(*)(int*)>;
using UniqueIntFree = std::unique_ptr<int, void(*)(void*)>;

// 仿函数删除器：可能零开销
struct Deleter {
    void operator()(int* p) const {
        delete p;
        std::cout << "Deleter 调用\n";
    }
};

int main() {
    UniqueInt a(new int(1));
    UniqueIntNew b(new int(2), [](int* p) { delete p; });
    // a = b;   // 编译错误：类型不同
    return 0;
}

8.2 shared_ptr 的类型擦除删除器

shared_ptr 的删除器不作为类型参数，运行时类型擦除：

#include <memory>
#include <cstdio>
#include <iostream>

int main() {
    // 不同删除器，相同类型 shared_ptr<FILE>
    std::shared_ptr<FILE> f1(std::fopen("a.txt", "r"), std::fclose);
    std::shared_ptr<FILE> f2(std::fopen("b.txt", "r"),
                              [](FILE* f) {
                                  std::fclose(f);
                                  std::cout << "lambda 关闭\n";
                              });

    // 类型擦除：删除器存储在控制块
    std::cout << "sizeof(f1) = " << sizeof(f1) << "\n";  // 输出: 16
    std::cout << "sizeof(f2) = " << sizeof(f2) << "\n";  // 输出: 16
    return 0;
}

8.3 管理 C API 资源

#include <memory>
#include <cstdlib>
#include <cstdio>
#include <windows.h>
#include <iostream>

// 1. malloc/free
auto malloc_ptr(int n) {
    return std::unique_ptr<int, void(*)(void*)>(
        static_cast<int*>(std::malloc(n * sizeof(int))),
        std::free);
}

// 2. FILE*
auto open_file(const char* path, const char* mode) {
    return std::unique_ptr<FILE, decltype(&std::fclose)>(
        std::fopen(path, mode), std::fclose);
}

// 3. Windows HANDLE（实际是指针类型）
#ifdef _WIN32
auto create_handle() {
    return std::unique_ptr<std::remove_pointer_t<HANDLE>,
                            decltype(&CloseHandle)>(
        CreateEventW(nullptr, FALSE, FALSE, nullptr),
        CloseHandle);
}
#endif

// 4. POSIX fd（int 不是指针，需自定义删除器类）
struct FdDeleter {
    void operator()(int* fd) const {
        if (fd && *fd >= 0) {
            // POSIX close(*fd);
            std::cout << "close fd " << *fd << "\n";
        }
        delete fd;
    }
};
using UniqueFd = std::unique_ptr<int, FdDeleter>;

int main() {
    auto p = malloc_ptr(10);
    p[0] = 42;

    auto f = open_file("/tmp/test.txt", "w");
    std::fprintf(f.get(), "hello\n");

    auto fd = UniqueFd(new int(3));
    return 0;
}

8.4 SDL 资源管理

#include <memory>

// 假设 SDL2 头文件
struct SDL_Window;
struct SDL_Renderer;
extern "C" void SDL_DestroyWindow(SDL_Window*);
extern "C" void SDL_DestroyRenderer(SDL_Renderer*);

// RAII 包装器
template<typename T, void(*Deleter)(T*)>
struct SdlDeleter {
    void operator()(T* p) const { if (p) Deleter(p); }
};

template<typename T, void(*D)(T*)>
using SdlUnique = std::unique_ptr<T, SdlDeleter<T, D>>;

using UniqueWindow   = SdlUnique<SDL_Window,   SDL_DestroyWindow>;
using UniqueRenderer = SdlUnique<SDL_Renderer, SDL_DestroyRenderer>;

// 使用：与普通 unique_ptr 一致
// UniqueWindow win(SDL_CreateWindow(...));

8.5 类型擦除的代价

shared_ptr 的类型擦除删除器带来大小开销：

#include <memory>
#include <iostream>

int main() {
    std::cout << "sizeof(unique_ptr<int>) = "
              << sizeof(std::unique_ptr<int>) << "\n";           // 8
    std::cout << "sizeof(unique_ptr<int, void(*)(int*)>) = "
              << sizeof(std::unique_ptr<int, void(*)(int*)>) << "\n";  // 16
    std::cout << "sizeof(shared_ptr<int>) = "
              << sizeof(std::shared_ptr<int>) << "\n";           // 16
    std::cout << "sizeof(weak_ptr<int>) = "
              << sizeof(std::weak_ptr<int>) << "\n";             // 16
    return 0;
}

shared_ptr 与 weak_ptr 始终是 2 个字（16 字节）：一个指向对象，一个指向控制块。

第 9 章 对比分析

9.1 与裸指针对比

9.2 与 Rust Box/Rc/RefCell 对比

// Rust 等价示例
use std::rc::{Rc, Weak};
use std::cell::RefCell;

let a = Rc::new(RefCell::new(42));
let b = a.clone();                    // 引用计数 +1
let w: Weak<i32> = Rc::downgrade(&a); // 弱引用

// Rust 借用检查器在编译期保证：
// - 同一时刻只能有一个可变借用，或多个不可变借用
// - Box<T> 独占所有权，编译期禁止拷贝

9.3 与 Java 引用类型对比

Java 的 GC 能自动处理循环引用，但代价是非确定性回收与潜在暂停。

9.4 与 Go GC 对比

Go 不提供智能指针，所有引用默认共享，由 GC 自动管理。Go 的设计哲学是简化心智负担，C++ 则追求确定性资源管理。

9.5 设计哲学对比

graph TB
    A[资源管理哲学] --> B[C++ 智能指针<br/>确定性 + 显式所有权]
    A --> C[Rust 借用检查<br/>编译期 + 类型系统]
    A --> D[Java/Go GC<br/>运行时 + 自动回收]
    B --> B1[优势: 零暂停, 通用 RAII]
    B --> B2[劣势: 循环引用需手动]
    C --> C1[优势: 编译期保证]
    C --> C2[劣势: 学习曲线陡]
    D --> D1[优势: 心智简单]
    D --> D2[劣势: 暂停, 非确定]
    style B fill:#69f,color:#fff
    style C fill:#6c6,color:#fff
    style D fill:#f96,color:#000

第 10 章 常见陷阱

10.1 循环引用

错误示例：

#include <memory>

struct Node {
    std::shared_ptr<Node> next;
    std::shared_ptr<Node> prev;
};

int main() {
    auto a = std::make_shared<Node>();
    auto b = std::make_shared<Node>();
    a->next = b;
    b->prev = a;   // 循环引用！
    return 0;       // 内存泄漏
}

原因：strong(a) 与 strong(b) 互为 1，构成不动点。

修正：将一侧改为 weak_ptr：

#include <memory>

struct Node {
    std::shared_ptr<Node> next;
    std::weak_ptr<Node>   prev;
};

int main() {
    auto a = std::make_shared<Node>();
    auto b = std::make_shared<Node>();
    a->next = b;
    b->prev = a;   // 弱引用，不增加 strong count
    return 0;       // 正确析构
}

10.2 双重管理（Double-Free from Two shared_ptr）

错误示例：

#include <memory>

int main() {
    int* raw = new int(42);
    std::shared_ptr<int> p1(raw);
    std::shared_ptr<int> p2(raw);   // UB：两个独立控制块
    return 0;   // double-free
}

原因：每个 shared_ptr 构造都创建独立控制块，无法识别裸指针已被管理。

修正：

#include <memory>

int main() {
    auto p1 = std::make_shared<int>(42);
    auto p2 = p1;   // 共享同一控制块
    return 0;
}

10.3 move 后使用

错误示例：

#include <memory>
#include <iostream>

int main() {
    auto p = std::make_unique<int>(42);
    auto q = std::move(p);
    std::cout << *p << "\n";   // UB：p 已为空
    return 0;
}

原因：move 后源对象为空，解引用空指针是 UB。

修正：

#include <memory>
#include <iostream>

int main() {
    auto p = std::make_unique<int>(42);
    auto q = std::move(p);
    if (p) {
        std::cout << *p << "\n";   // 不执行
    } else {
        std::cout << "p 已为空\n";  // 输出: p 已为空
    }
    std::cout << *q << "\n";       // 输出: 42
    return 0;
}

10.4 误用 get()

错误示例：

#include <memory>

int main() {
    auto p = std::make_shared<int>(42);
    int* raw = p.get();
    p.reset();          // 对象析构
    // int x = *raw;    // UB：raw 悬垂
    return 0;
}

原因：get() 返回的裸指针不受智能指针管理，对象析构后悬垂。

修正：

#include <memory>
#include <iostream>

int main() {
    auto p = std::make_shared<int>(42);
    int* raw = p.get();
    // 仅在 p 存活期间使用 raw
    std::cout << *raw << "\n";   // 输出: 42
    // 不要将 raw 保存到生命周期超过 p 的位置
    return 0;
}