RAII资源管理

第 1 章 学习目标与导论

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

RAII（Resource Acquisition Is Initialization，资源获取即初始化，由 Bjarne Stroustrup 于 1980s 在设计 C++ 时提出，将资源生命周期与对象生命周期绑定）是 C++ 语言最具辨识度的核心范式，也是 C++ 区别于 C、Java、Python 等语言的标志性特征。它位于 C++ 知识体系的”资源管理层”，向上承接面向对象与异常机制，向下衔接智能指针、并发原语、模板元编程等高级特性。

掌握本章前，读者应当已经熟悉：

• cpp/概述与现代标准：C++ 的设计哲学与现代标准演进
• cpp/基础语法：作用域、生命周期、控制流
• cpp/数据类型详解：基本类型、复合类型与存储期
• cpp/指针：原始指针的内存模型与所有权语义
• cpp/面向对象基础：构造、析构、拷贝、移动的语义

掌握本章后，读者将为后续学习 cpp/智能指针详解、cpp/右值引用与移动语义、cpp/并发编程、cpp/异常处理、cpp/模板元编程 等高级主题奠定坚实基础。

1.2 学习目标

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

1. 记忆（Remember）：复述 RAII 的形式化定义与对象-资源生命周期同构映射的不变量（invariant，源自拉丁语 “in-” 不 + “variare” 变化，指对象生命周期内始终保持成立的逻辑条件），识别构造、析构、栈展开（Stack Unwinding，“unwind” 解开、回绕，隐喻异常抛出时逐帧回溯调用栈的过程）的关键语义。
2. 理解（Understand）：解释栈展开机制的确定性析构语义，说明 RAII 如何在异常路径下保证资源释放，分析 basic、strong、nothrow 三级异常安全保证的可达条件与代价。
3. 应用（Apply）：使用 RAII 模式封装文件句柄、动态内存、互斥锁、网络套接字、数据库事务、OpenGL 纹理/VBO、CUDA 资源等异质资源，编写异常安全且零开销的代码。
4. 分析（Analyze）：对比 unique_ptr、shared_ptr、weak_ptr 的所有权（ownership，借用日常语义，指”负责管理某资源生命周期”的责任归属）语义差异，识别循环引用、移动后状态、双重释放等问题的成因。
5. 评估（Evaluate）：评估 RAII 与垃圾回收（GC）、Java try-finally、Python with、Go defer、Rust Drop trait 在不同场景下的优劣，论证选择依据。
6. 创造（Create）：设计基于 Scope Guard（作用域守卫，由 Andrei Alexandrescu 于 2000 年提出）、Pimpl、Transaction 的工程级资源管理抽象，构造支持自定义删除器、移动语义与 ABI 稳定性的 RAII 类模板。

1.3 阅读建议

• 零基础读者：先通读第 2、3、5 章建立概念框架，再阅读第 6-13 章的具体资源类型实践；
• 有 C 语言基础读者：重点关注第 4 章理论推导与第 14 章跨语言对比，理解 RAII 解决的 C 时代痛点；
• 进阶读者：直接研读第 15 章陷阱分析、第 16 章工程实践与第 17 章开源项目案例。

第 2 章 历史动机与演进

2.1 1970s：C 时代的资源管理困境

C 语言诞生于 1972 年，Dennis Ritchie 在贝尔实验室设计 C 时未提供自动资源管理机制。所有资源（内存、文件句柄、锁、套接字）均需程序员手动调用 malloc/free、fopen/fclose、lock/unlock、socket/close 等配对函数管理。这种”手动配对”模式存在三类系统性缺陷：

1. 遗忘释放：函数在错误路径上提前 return 或 goto 时跳过释放语句，导致资源泄漏。
2. 双重释放：同一资源被释放两次，破坏分配器内部状态，可能引发安全漏洞（如 CVE-2014-0160 Heartbleed 的近亲）。
3. 异常路径失控：在支持异常的语言中，函数抛出异常时所有释放代码被跳过，资源必然泄漏。

C 时代典型的”goto cleanup”模式反映了这一困境：

/* C 语言经典的 goto cleanup 错误处理模式 */
#include <stdio.h>
#include <stdlib.h>

int process_file(const char* path) {
    FILE* f = fopen(path, "r");
    if (!f) return -1;                  /* 文件打开失败 */

    char* buf = malloc(1024);
    if (!buf) {
        fclose(f);                      /* 必须手动关闭文件 */
        return -2;
    }

    if (fread(buf, 1, 1024, f) < 0) {
        free(buf);                      /* 必须手动释放内存 */
        fclose(f);                      /* 必须手动关闭文件 */
        return -3;
    }

    /* 处理 buf ... */

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

该模式的问题在于：每增加一个资源，错误路径的数量呈指数增长，程序员必须为每个错误路径编写正确的清理代码。Stroustrup 在《The Design and Evolution of C++》中明确指出：“C 的资源管理依赖程序员的纪律，而非语言保证；这种纪律在大规模软件中不可持续”。

2.2 1985：Bjarne Stroustrup 与 RAII 的诞生

1985 年，Bjarne Stroustrup 在贝尔实验室发布 C++ 首个商用版本 Cfront。C++ 的核心设计目标之一是”在不牺牲 C 的系统级编程能力的前提下，提供更强的类型安全与抽象机制”。Stroustrup 在设计类机制时观察到：

“对象的生命周期与对象所管理的资源的生命周期存在自然的同构关系。构造函数获取资源，析构函数释放资源，这一对称性可以将资源管理从’程序员的纪律’转化为’语言的保证’。”

——Stroustrup, B. The Design and Evolution of C++. 1994, §15.4

这一观察被形式化为 RAII 范式：

• 构造函数：获取资源；若获取失败，抛出异常，对象不构造。
• 析构函数：释放资源；C++ 保证栈对象离开作用域时析构函数必定被调用，即使发生异常。
• 拷贝与移动：通过删除或自定义拷贝/移动操作，明确资源所有权的转移语义。

RAII 的关键创新在于利用 C++ 已有的”自动存储期”机制（栈对象的构造与析构），将资源管理”附赠”在对象生命周期管理之上，实现零额外开销。

2.3 Stack Unwinding 机制的标准化历程

RAII 的异常安全保证依赖于栈展开（Stack Unwinding）机制。当 C++ 异常被抛出时，运行时从抛出点开始，逐帧回溯调用栈，对每个栈帧中的自动对象调用析构函数，直至找到匹配的 catch 块。这一机制的标准化经历了三个阶段：

1. Cfront 时代（1985-1989）：Cfront 1.0 不支持异常，RAII 仅保证正常路径的确定性析构。
2. C++ 异常机制引入（1989-1996）：AT&T 的 Andrew Koenig 与 Bjarne Stroustrup 设计了基于表驱动（table-driven）的异常机制，栈展开成为语言规范的一部分。1993 年 ISO C++ 工作组将异常机制纳入工作草案，最终在 1998 年 C++98 标准中正式定稿。
3. C++11 noexcept 改革（2011）：C++11 引入 noexcept 关键字替代 throw() 动态异常规范，析构函数默认 noexcept，进一步强化”析构不抛异常”的约定。

栈展开机制的形式化保证（详见第 4 章）是 RAII 异常安全的基石：无论函数从哪个 return 退出、是否抛出异常，所有自动对象的析构函数都会被调用。

下图展示 RAII 范式与 C++ 语言演进的关键时间节点：

timeline
    title RAII 范式与 C++ 语言演进时间线
    section C 时代
        1972 : Dennis Ritchie 设计 C 语言<br/>手动 malloc/free 资源管理
        1979 : Bjarne Stroustrup 启动 "C with Classes"
    section C++ 诞生与 RAII 雏形
        1985 : Cfront 1.0 发布<br/>RAII 范式雏形（无异常支持）
        1989 : 异常机制设计启动<br/>Koenig-Stroustrup 表驱动方案
    section 标准化与异常安全
        1998 : ISO C++98 标准发布<br/>Stack Unwinding 形式化
        2003 : C++03 (ISO/IEC 14882:2003)
    section 现代 C++ 与智能指针
        2011 : C++11 引入 unique_ptr/shared_ptr/weak_ptr<br/>noexcept 改革
        2014 : C++14 引入 std::make_unique
        2017 : C++17 引入 scoped_lock/jthread<br/>移除 auto_ptr
    section 精细化阶段
        2020 : C++20 引入 span/format/bit<br/>Concepts 约束 RAII 模板
        2023 : C++23 引入 expected/optional 扩展<br/>std::print RAII 包装

2.4 C++11：智能指针的标准化

C++98 标准库提供 std::auto_ptr，但其破坏性复制语义（复制构造隐式转移所有权）违反值语义直觉，且不满足 STL 容器的 CopyConstructible 要求。C++11 引入右值引用与移动语义后，标准委员会重新设计了智能指针体系：

C++11 同时引入 std::lock_guard、std::unique_lock、std::scoped_allocator 等 RAII 工具，使 RAII 成为现代 C++ 的”默认编程范式”。

2.5 C++17/20/23：RAII 的精细化

后续标准持续完善 RAII 工具链：

• C++17：引入 std::scoped_lock（多锁原子获取）、std::byte（替代 char* 表示原始字节）、std::optional（可选值的 RAII 包装）。
• C++20：引入 std::span<T>（非拥有视图，替代 T* + 长度）、std::jthread（自动 join 的线程 RAII）、std::stop_token（协作式取消）。
• C++23：引入 std::expected<T, E>（值或错误的 RAII 包装）、std::mdspan（多维视图）、std::move_only_function（move-only 的 std::function）。
• C++26（提案）：计划引入 std::scope_guard（通用作用域守卫）、模式匹配中的析构语义、契约编程的析构后置条件。

第 3 章 形式化定义

3.1 RAII 的形式化定义

为消除自然语言歧义，本节以数学形式化方式定义 RAII 语义，对应 C++ 标准 [class.dtor] 与 [except.handle] 的规定。

设 $\mathcal{R}$ 为资源集合（内存、文件描述符、锁、套接字等），$\mathcal{O}$ 为对象集合，$\mathcal{S}$ 为程序执行状态集合。定义以下函数：

• $\text{acquire}: \mathcal{S} \to \mathcal{R} \times \mathcal{S}$：从状态中获取资源，返回资源与新状态。
• $\text{release}: \mathcal{R} \times \mathcal{S} \to \mathcal{S}$：释放资源，返回新状态。
• $\text{life}: \mathcal{O} \to 2^{\mathcal{S}}$：对象的生命周期，即从构造完成到析构开始的状态集合。

定义 3.1（RAII 对象）：对象 $o \in \mathcal{O}$ 是 RAII 对象，当且仅当存在资源 $r \in \mathcal{R}$ 与函数 $\phi: \mathcal{S} \to \mathcal{R} \cup \{\bot\}$（资源句柄），满足：

$\forall s \in \text{life}(o): \phi(s) = r \quad \wedge \quad \forall s \notin \text{life}(o): \phi(s) = \bot$

即对象生命周期内持有资源，生命周期外不持有。这构成了 RAII 的对象-资源同构映射。

定义 3.2（RAII 构造与析构）：

$\text{construct}(o, s_0) = (r, s_1) \quad \Rightarrow \quad \text{destruct}(o, s_2) = \text{release}(r, s_2)$

即构造函数获取资源 $r$，析构函数释放 $r$。这一对称性是 RAII 的核心约束。

3.2 不变量的数学表述

RAII 类的不变量（invariant）是其正确性的数学保证。设 RAII 类 $C$ 管理资源 $r$，其不变量 $\mathcal{I}_C$ 定义为：

$\mathcal{I}_C(o) \triangleq \text{valid}(o) \Rightarrow \text{owns}(o, r) \oplus \text{moved\_from}(o)$

其中 $\text{valid}(o)$ 表示对象处于有效状态，$\text{owns}(o, r)$ 表示对象持有资源，$\text{moved\_from}(o)$ 表示对象已被移动（处于有效但未指定状态）。$\oplus$ 表示异或，即对象要么持有资源，要么处于移动后状态，二者互斥。

关键推论：

1. 构造后不变量成立：构造成功的对象必定持有资源。
2. 析构前不变量成立：析构函数被调用时对象必定持有资源（除非已被移动）。
3. 移动后状态安全：移动后的对象处于”有效但未指定”状态，其析构函数必须是空操作（不重复释放资源）。

3.3 析构函数调用的确定性语义

C++ 标准对析构函数的调用时机做出严格规定：

定理 3.1（确定性析构）：对于自动存储期对象 $o$，其析构函数在以下时机被调用：

1. 作用域正常退出：控制流离开 $o$ 所在的作用域（通过 return、goto、break、continue）。
2. 栈展开：异常抛出后，栈展开至 $o$ 所在栈帧时。
3. 程序终止：std::exit 或 main 返回时（仅对静态存储期对象）。

形式化地，设 $\text{scope}(o)$ 为 $o$ 所在作用域的执行区间，$\text{exit\_points}(\text{scope}(o))$ 为该作用域的所有退出点（含异常退出），则：

$\forall e \in \text{exit\_points}(\text{scope}(o)): \text{destruct}(o) \in \text{path}(e)$

即无论从哪个退出点离开作用域，析构函数都在退出路径上被调用。这一性质是 RAII 异常安全的根本保证。

对比 GC 的非确定性：Java/C# 等语言的 GC 在不可预测的时机回收对象，对象终结器（finalizer）的调用时机不确定，甚至可能永不调用。因此 GC 语言需额外的 try-with-resources（Java）、using（C#）机制实现确定性资源释放，本质是 RAII 的”补丁”。

第 4 章 理论推导

4.1 Stack Unwinding 机制的正确性证明

栈展开机制的正确性可通过不变式归纳证明。

命题 4.1（栈展开完整性）：设异常在栈帧 $F_k$ 抛出，匹配的 catch 块位于栈帧 $F_0$（$F_0$ 是 $F_k$ 的祖先），则栈展开过程必然对 $F_k, F_{k-1}, \dots, F_1$ 中的所有自动对象调用析构函数。

证明（结构归纳）：

1. 基础情况：栈展开从 $F_k$ 开始。$F_k$ 中异常抛出点之后的自动对象尚未构造（构造顺序与声明顺序一致），无需析构。抛出点之前的自动对象已构造，按声明逆序调用析构函数。归纳基础成立。

2. 归纳步骤：假设栈展开已正确处理 $F_i$（$i > 0$）。$F_{i-1}$ 是 $F_i$ 的调用者，调用点之后的自动对象尚未构造（因为 $F_i$ 还未返回）。调用点之前的自动对象已构造，按声明逆序析构。栈展开继续至 $F_{i-1}$ 的调用点，处理 $F_{i-1}$ 中尚未析构的自动对象。

3. 终止条件：栈展开至 $F_0$ 时，找到匹配的 catch 块，展开终止。若至 main 仍未匹配，调用 std::terminate。

由归纳法，栈展开必然对所有相关自动对象调用析构函数。$\blacksquare$

推论 4.1（RAII 异常安全）：若所有资源均由 RAII 对象管理，则任意异常路径下所有已获取的资源都会被释放，不存在资源泄漏。

下图展示异常抛出后栈展开过程的调用栈状态变化：

flowchart TB
    accTitle: Stack Unwinding Mechanism Flow
    accDescr: Flowchart showing how C++ stack unwinding walks through call frames calling destructors when an exception is thrown until a matching catch is found.

    start([异常抛出点]) --> check1{当前栈帧 F_k<br/>是否有匹配 catch?}
    check1 -->|否| destruct1[按声明逆序<br/>调用 F_k 已构造对象的析构]
    destruct1 --> pop1[弹出 F_k 栈帧]
    pop1 --> move1[回溯至调用者 F_{k-1}]
    move1 --> check2{F_{k-1} 是否有匹配 catch?}
    check2 -->|否| destruct2[按声明逆序<br/>调用 F_{k-1} 已构造对象的析构]
    destruct2 --> pop2[弹出 F_{k-1} 栈帧]
    pop2 --> move2[回溯至调用者 F_{k-2}]
    move2 --> checkN{F_0 是否有匹配 catch?}
    checkN -->|是| handler[进入 catch 块<br/>执行异常处理]
    checkN -->|否| terminate[调用 std::terminate<br/>程序终止]
    handler --> continue([继续执行 catch 后续代码])

    style start fill:#fee2e2,stroke:#dc2626,color:#7f1d1d
    style terminate fill:#fee2e2,stroke:#dc2626,color:#7f1d1d
    style handler fill:#dcfce7,stroke:#16a34a,color:#14532d
    style continue fill:#dcfce7,stroke:#16a34a,color:#14532d
    style destruct1 fill:#fef9c3,stroke:#ca8a04,color:#713f12
    style destruct2 fill:#fef9c3,stroke:#ca8a04,color:#713f12
    style pop1 fill:#e0e7ff,stroke:#4f46e5,color:#312e81
    style pop2 fill:#e0e7ff,stroke:#4f46e5,color:#312e81

4.2 异常安全保证的形式化分析

Abrahams 异常安全保证体系定义了三级保证：

4.2.1 Basic Guarantee（基本保证）

定义：操作失败时不泄漏资源，且对象保持有效（但可能改变）状态。

形式化：$\forall op, s_0: \text{throws}(op, s_0) \Rightarrow \exists s_1: \text{valid}(s_1) \wedge \text{no\_leak}(s_1) \wedge s_1 = \text{state\_after}(op, s_0)$。

RAII 通过确定性析构天然满足基本保证：即使操作抛异常，所有 RAII 对象的析构函数被调用，资源不泄漏。

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

// 基本保证示例：异常时不泄漏，但状态可能改变
class Buffer {
    std::unique_ptr<char[]> data_;
    size_t size_;
public:
    Buffer(size_t n) : data_(std::make_unique<char[]>(n)), size_(n) {}
    void resize(size_t new_size) {
        auto new_data = std::make_unique<char[]>(new_size);  // 可能抛 bad_alloc
        std::copy(data_.get(), data_.get() + std::min(size_, new_size), new_data.get());
        data_ = std::move(new_data);                          // 不抛
        size_ = new_size;
    }
    size_t size() const { return size_; }
};
// 输出：异常路径下 data_ 仍指向原缓冲（new_data 析构释放新分配），无泄漏

4.2.2 Strong Guarantee（强保证）

定义：操作要么成功，要么回滚到操作前的状态（事务语义）。

形式化：$\forall op, s_0: \text{throws}(op, s_0) \Rightarrow \text{state\_after}(op, s_0) = s_0$。

实现技巧是”copy-and-swap”：先在临时副本上执行操作，成功后无抛出地交换。

#include <memory>
#include <algorithm>

// 强保证示例：copy-and-swap 惯用法
class StringVec {
    std::unique_ptr<std::string[]> data_;
    size_t size_, capacity_;
public:
    StringVec(size_t cap) : data_(std::make_unique<std::string[]>(cap)), size_(0), capacity_(cap) {}
    void push_back(const std::string& s) {
        // 1. 在临时副本上操作
        auto new_data = std::make_unique<std::string[]>(capacity_ * 2);  // 可能抛
        for (size_t i = 0; i < size_; ++i) new_data[i] = data_[i];       // 可能抛 bad_alloc
        new_data[size_] = s;                                              // 可能抛
        // 2. 无抛出交换
        data_ = std::move(new_data);                                      // noexcept
        capacity_ *= 2;
        ++size_;
    }
    // 异常路径：new_data 析构释放临时副本，原状态不变（强保证）
};

4.2.3 Nothrow Guarantee（不抛保证）

定义：操作绝不抛出异常。

形式化：$\forall op, s_0: \neg\text{throws}(op, s_0)$。

C++11 后通过 noexcept 标注表达。析构函数、移动构造、移动赋值、swap 应尽量 noexcept。

#include <utility>
#include <iostream>

// Nothrow 保证示例：移动构造与 swap 标记 noexcept
class FixedBuffer {
    char buf_[1024];
    size_t len_;
public:
    FixedBuffer() : len_(0) {}
    // 移动构造 noexcept：仅拷贝字节 + 清零源
    FixedBuffer(FixedBuffer&& o) noexcept {
        std::copy(o.buf_, o.buf_ + o.len_, buf_);
        len_ = o.len_;
        o.len_ = 0;
    }
    FixedBuffer& operator=(FixedBuffer&& o) noexcept {
        if (this != &o) {
            std::copy(o.buf_, o.buf_ + o.len_, buf_);
            len_ = o.len_;
            o.len_ = 0;
        }
        return *this;
    }
    void swap(FixedBuffer& o) noexcept {
        FixedBuffer tmp = std::move(*this);
        *this = std::move(o);
        o = std::move(tmp);
    }
};
// 输出：移动与 swap 永不抛异常，可用于 STL 容器的强保证实现

4.3 RAII 与 GC 的复杂度对比

设 $n$ 为对象数量，$R$ 为资源数量，$H$ 为堆大小。

推导：RAII 的释放复杂度为 $O(1)$，因为析构函数直接调用 free/fclose/unlock 等，无扫描开销。GC 的单次回收复杂度为 $O(H)$（Mark-Sweep）或 $O(H_{gen})$（分代），因为需遍历对象图判断可达性。

内存峰值：RAII 即时释放，峰值约为实际使用量；GC 等待堆水位触发回收，峰值通常为实际使用量的 1.5-3 倍。

实时性：RAII 无 STW 暂停，适合实时系统；GC 的暂停时间在 100ms 量级（G1、ZGC 可降至 10ms），仍不适合硬实时系统。

第 5 章 RAII 的核心机制

RAII 对象的生命周期可建模为有限状态机，下图展示其状态迁移与触发条件：

stateDiagram-v2
    accTitle: RAII Object Lifecycle State Machine
    accDescr: State diagram showing the lifecycle of an RAII object from construction through resource acquisition, move operations, and destruction with guaranteed cleanup.

    [*] --> 未构造
    未构造 --> 已构造_持有资源 : 构造函数成功<br/>资源获取成功
    未构造 --> [*] : 构造函数抛异常<br/>资源获取失败
    已构造_持有资源 --> 已移动_空状态 : 移动构造/移动赋值<br/>资源所有权转移
    已移动_空状态 --> 已构造_持有资源 : 移动赋值<br/>接收新资源
    已构造_持有资源 --> 已析构 : 离开作用域<br/>析构函数调用
    已移动_空状态 --> 已析构 : 离开作用域<br/>析构函数（空操作）
    已构造_持有资源 --> 已构造_持有资源 : 拷贝（若允许）<br/>引用计数增加
    已析构 --> [*]

    note right of 已构造_持有资源
        不变量：file_ != nullptr
        资源有效，可访问
    end note

    note right of 已移动_空状态
        不变量：file_ == nullptr
        析构为空操作
    end note

    note right of 已析构
        资源已释放
        不可访问
    end note

5.1 构造-析构对称性

RAII 的最简形式是”构造获取、析构释放”的对称结构：

#include <cstdio>
#include <stdexcept>

// 最简 RAII 类：构造获取文件句柄，析构释放
class FileHandle {
    std::FILE* file_;
public:
    // 构造函数获取资源，失败抛异常使对象不构造
    explicit FileHandle(const char* path, const char* mode)
        : file_(std::fopen(path, mode)) {
        if (!file_) throw std::runtime_error("fopen failed");
    }
    // 析构函数释放资源，noexcept 默认
    ~FileHandle() { if (file_) std::fclose(file_); }
    // 禁用拷贝避免双重释放
    FileHandle(const FileHandle&) = delete;
    FileHandle& operator=(const FileHandle&) = delete;
    // 访问器
    std::FILE* get() const noexcept { return file_; }
};
// 输出：作用域结束自动 fclose，异常路径同样保证释放

5.2 作用域与生命周期

RAII 的资源释放与作用域严格绑定：

#include <iostream>
#include <memory>

struct Trace {
    const char* name;
    Trace(const char* n) : name(n) { std::cout << name << " construct\n"; }
    ~Trace() { std::cout << name << " destruct\n"; }
};

void demo_scope() {
    Trace outer("outer");               // outer 构造
    {
        Trace inner("inner");           // inner 构造
        std::cout << "block body\n";
    }                                   // inner 析构（LIFO）
    std::cout << "after block\n";
}                                       // outer 析构
// 输出：
// outer construct
// inner construct
// block body
// inner destruct
// after block
// outer destruct

int main() { demo_scope(); return 0; }

5.3 移动语义与所有权转移

C++11 移动语义使 RAII 类支持所有权转移，而无需深拷贝：

#include <iostream>
#include <memory>
#include <utility>

class Buffer {
    int* data_;
    size_t size_;
public:
    explicit Buffer(size_t n) : data_(new int[n]), size_(n) {
        std::cout << "allocate " << size_ << " ints\n";
    }
    ~Buffer() {
        if (data_) {
            std::cout << "deallocate " << size_ << " ints\n";
            delete[] data_;
        }
    }
    // 移动构造：转移所有权，源置空
    Buffer(Buffer&& o) noexcept : data_(o.data_), size_(o.size_) {
        o.data_ = nullptr;
        o.size_ = 0;
        std::cout << "move construct\n";
    }
    // 移动赋值：先释放自身，再转移
    Buffer& operator=(Buffer&& o) noexcept {
        if (this != &o) {
            delete[] data_;
            data_ = o.data_;
            size_ = o.size_;
            o.data_ = nullptr;
            o.size_ = 0;
            std::cout << "move assign\n";
        }
        return *this;
    }
    // 禁用拷贝
    Buffer(const Buffer&) = delete;
    Buffer& operator=(const Buffer&) = delete;
};

int main() {
    Buffer a(10);                       // allocate 10 ints
    Buffer b = std::move(a);            // move construct（a 置空，b 持有）
    // a 现在为有效但未指定状态，析构时 data_ 为 nullptr 不释放
    return 0;
}
// 输出：
// allocate 10 ints
// move construct
// deallocate 10 ints（b 析构）

5.4 删除器与自定义释放逻辑

unique_ptr 支持自定义删除器，使同一类型适配不同释放策略：

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

// 自定义删除器：函数对象
struct FileCloser {
    void operator()(std::FILE* f) const noexcept {
        if (f) { std::fclose(f); std::cout << "file closed\n"; }
    }
};

// 自定义删除器：Lambda
auto malloc_deleter = [](void* p) noexcept {
    if (p) { std::free(p); std::cout << "malloc freed\n"; }
};

using UniqueFile = std::unique_ptr<std::FILE, FileCloser>;
using UniqueMalloc = std::unique_ptr<void, decltype(malloc_deleter)>;

int main() {
    UniqueFile fp(std::fopen("test.txt", "w"));
    if (fp) std::fprintf(fp.get(), "hello");

    UniqueMalloc mp(std::malloc(1024));
    // 作用域结束自动调用删除器
    return 0;
}
// 输出（假设 test.txt 可创建）：
// malloc freed
// file closed

5.5 五法则与零法则

C++ 资源管理遵循两条核心法则：

Rule of Five（五法则）：若类需要自定义析构、拷贝构造、拷贝赋值、移动构造、移动赋值中的任一项，通常需要自定义全部五项。

Rule of Zero（零法则）：若类成员均为 RAII 类型（如 unique_ptr、vector、string），则无需自定义任何特殊成员函数，编译器生成的默认实现即可正确管理资源。

#include <memory>
#include <string>
#include <vector>

// 零法则示例：所有成员均为 RAII 类型，无需自定义特殊成员函数
class Person {
    std::string name_;              // RAII
    std::vector<int> scores_;       // RAII
    std::unique_ptr<int> age_;      // RAII
public:
    Person(std::string n, std::unique_ptr<int> a)
        : name_(std::move(n)), age_(std::move(a)) {}
    // 编译器生成的析构、拷贝、移动全部正确（拷贝被 unique_ptr 隐式禁用）
};

int main() {
    auto p = std::make_unique<Person>("Alice", std::make_unique<int>(30));
    // p 离开作用域自动析构 Person，进而析构 name_、scores_、age_
    return 0;
}

第 6 章 文件句柄管理

6.1 ifstream/ofstream 包装

C++ 标准库的 std::ifstream/std::ofstream/std::fstream 本身即 RAII 类，构造时打开文件，析构时关闭：

#include <fstream>
#include <iostream>
#include <string>

int main() {
    {
        std::ofstream out("output.txt");   // 构造打开文件
        out << "hello RAII\n";
        out << "line 2\n";
    }                                       // 析构关闭文件，即使未 flush
    std::cout << "file closed automatically\n";

    {
        std::ifstream in("output.txt");
        std::string line;
        while (std::getline(in, line)) {
            std::cout << "read: " << line << "\n";
        }
    }
    return 0;
}
// 输出：
// file closed automatically
// read: hello RAII
// read: line 2

6.2 FILE* 的 RAII 封装

C 风格 FILE* 需手动 fclose，可封装为 RAII 类：

#include <cstdio>
#include <stdexcept>
#include <string>
#include <utility>

class CFile {
    std::FILE* fp_;
public:
    explicit CFile(const char* path, const char* mode)
        : fp_(std::fopen(path, mode)) {
        if (!fp_) throw std::runtime_error(std::string("fopen failed: ") + path);
    }
    ~CFile() {
        if (fp_) {
            std::fclose(fp_);
            fp_ = nullptr;
        }
    }
    CFile(const CFile&) = delete;
    CFile& operator=(const CFile&) = delete;
    CFile(CFile&& o) noexcept : fp_(o.fp_) { o.fp_ = nullptr; }
    CFile& operator=(CFile&& o) noexcept {
        if (this != &o) {
            if (fp_) std::fclose(fp_);
            fp_ = o.fp_;
            o.fp_ = nullptr;
        }
        return *this;
    }
    std::FILE* get() const noexcept { return fp_; }
    int fileno() const noexcept { return ::fileno(fp_); }
};

int main() {
    try {
        CFile f("test.txt", "w");
        std::fprintf(f.get(), "RAII wrapped FILE*\n");
        // 作用域结束自动 fclose
    } catch (const std::exception& e) {
        std::printf("error: %s\n", e.what());
    }
    return 0;
}
// 输出（假设 test.txt 可创建）：写入 "RAII wrapped FILE*" 后自动关闭

6.3 文件描述符的 RAII 封装

POSIX 文件描述符（int）需 close()，封装为 RAII：

#include <fcntl.h>
#include <unistd.h>
#include <stdexcept>
#include <utility>

class FdGuard {
    int fd_;
public:
    explicit FdGuard(int fd) noexcept : fd_(fd) {}
    FdGuard(const char* path, int flags) {
        fd_ = ::open(path, flags);
        if (fd_ < 0) throw std::runtime_error("open failed");
    }
    ~FdGuard() noexcept {
        if (fd_ >= 0) ::close(fd_);
    }
    FdGuard(const FdGuard&) = delete;
    FdGuard& operator=(const FdGuard&) = delete;
    FdGuard(FdGuard&& o) noexcept : fd_(o.fd_) { o.fd_ = -1; }
    FdGuard& operator=(FdGuard&& o) noexcept {
        if (this != &o) {
            if (fd_ >= 0) ::close(fd_);
            fd_ = o.fd_;
            o.fd_ = -1;
        }
        return *this;
    }
    int get() const noexcept { return fd_; }
    int release() noexcept {
        int t = fd_; fd_ = -1; return t;
    }
    void reset(int new_fd) noexcept {
        if (fd_ >= 0) ::close(fd_);
        fd_ = new_fd;
    }
};

int main() {
    FdGuard fd("/tmp/test.txt", O_WRONLY | O_CREAT | O_TRUNC);
    ::write(fd.get(), "hello fd\n", 9);
    return 0;
}
// 输出：写入 /tmp/test.txt 后自动 close fd

6.4 内存映射文件的 RAII

mmap/munmap 也可封装为 RAII：

#include <sys/mman.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdexcept>

class MappedFile {
    void* addr_;
    size_t size_;
public:
    MappedFile(const char* path, int prot, int flags) {
        int fd = ::open(path, O_RDONLY);
        if (fd < 0) throw std::runtime_error("open failed");
        struct stat st;
        if (::fstat(fd, &st) < 0) { ::close(fd); throw std::runtime_error("fstat failed"); }
        size_ = static_cast<size_t>(st.st_size);
        addr_ = ::mmap(nullptr, size_, prot, flags, fd, 0);
        ::close(fd);
        if (addr_ == MAP_FAILED) throw std::runtime_error("mmap failed");
    }
    ~MappedFile() noexcept {
        if (addr_ && addr_ != MAP_FAILED) ::munmap(addr_, size_);
    }
    MappedFile(const MappedFile&) = delete;
    MappedFile& operator=(const MappedFile&) = delete;
    const void* data() const noexcept { return addr_; }
    size_t size() const noexcept { return size_; }
};
// 输出：析构自动 munmap，异常路径同样安全

第 7 章 内存管理

7.1 unique_ptr 详解

std::unique_ptr 是独占所有权的智能指针，零开销抽象（无引用计数），移动语义转移所有权：

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

struct Widget {
    int id;
    Widget(int i) : id(i) { std::cout << "Widget " << id << " construct\n"; }
    ~Widget() { std::cout << "Widget " << id << " destruct\n"; }
    void use() const { std::cout << "Widget " << id << " used\n"; }
};

// 工厂函数返回 unique_ptr
std::unique_ptr<Widget> make_widget(int id) {
    return std::make_unique<Widget>(id);   // C++14 异常安全构造
}

void consumer(std::unique_ptr<Widget> p) {
    if (p) p->use();
    // p 在函数结束时析构 Widget
}

int main() {
    auto p = make_widget(1);               // Widget 1 construct
    consumer(std::move(p));                 // Widget 1 used / Widget 1 destruct
    std::cout << "p is " << (p ? "non-null" : "null") << "\n";

    // 容器持有 unique_ptr
    std::vector<std::unique_ptr<Widget>> v;
    v.push_back(make_widget(2));            // Widget 2 construct
    v.push_back(make_widget(3));            // Widget 3 construct
    for (const auto& w : v) w->use();
    return 0;
}
// 输出：
// Widget 1 construct
// Widget 1 used
// Widget 1 destruct
// p is null
// Widget 2 construct
// Widget 3 construct
// Widget 2 used
// Widget 3 used
// Widget 3 destruct
// Widget 2 destruct

7.2 unique_ptr 数组特化

unique_ptr<T[]> 特化用于动态数组，自动调用 delete[]：

#include <memory>
#include <iostream>

int main() {
    auto arr = std::make_unique<int[]>(5);  // 分配 5 个 int
    for (size_t i = 0; i < 5; ++i) arr[i] = i * i;
    for (size_t i = 0; i < 5; ++i) std::cout << arr[i] << ' ';
    std::cout << "\n";
    return 0;
}
// 输出：0 1 4 9 16

7.3 shared_ptr 与引用计数

std::shared_ptr 通过原子引用计数（reference counting，维护指向对象的引用数量，归零时释放）实现共享所有权：

#include <iostream>
#include <memory>

int main() {
    auto sp1 = std::make_shared<int>(42);
    std::cout << "count=" << sp1.use_count() << ", val=" << *sp1 << "\n";  // count=1, val=42

    {
        auto sp2 = sp1;                    // 拷贝增加计数
        auto sp3 = sp2;                    // 计数=3
        std::cout << "count=" << sp1.use_count() << "\n";  // count=3
    }                                      // sp2、sp3 析构，计数=1

    std::cout << "count=" << sp1.use_count() << "\n";      // count=1
    return 0;
}
// 输出：
// count=1, val=42
// count=3
// count=1

make_shared 的优势：将对象与控制块合并为单次堆分配，提升缓存局部性。

7.4 weak_ptr 与循环引用

循环引用是 shared_ptr 的经典陷阱，weak_ptr 用于打破环：

#include <iostream>
#include <memory>

struct Node;
struct Node {
    std::shared_ptr<Node> next;
    std::weak_ptr<Node>   prev;            // 弱引用打破循环
    int value;
    Node(int v) : value(v) { std::cout << "Node " << v << " construct\n"; }
    ~Node() { std::cout << "Node " << value << " destruct\n"; }
};

int main() {
    auto a = std::make_shared<Node>(1);
    auto b = std::make_shared<Node>(2);
    a->next = b;                           // b 计数=2
    b->prev = a;                           // a 计数=2（weak_ptr 不增加）
    std::cout << "a count=" << a.use_count() << "\n";  // a count=2
    std::cout << "b count=" << b.use_count() << "\n";  // b count=2

    // 使用 weak_ptr 前需 lock() 升级为 shared_ptr
    if (auto locked = b->prev.lock()) {
        std::cout << "prev value=" << locked->value << "\n";  // prev value=1
    }
    return 0;
}
// 输出：
// Node 1 construct
// Node 2 construct
// a count=2
// b count=2
// prev value=1
// Node 2 destruct
// Node 1 destruct

7.5 enable_shared_from_this

类需在成员函数中获取自身的 shared_ptr 时，继承 std::enable_shared_from_this：

#include <memory>
#include <iostream>

class Worker : public std::enable_shared_from_this<Worker> {
public:
    void start() {
        // 错误：shared_from_this() 必须在对象已由 shared_ptr 管理时调用
        auto self = shared_from_this();
        std::cout << "Worker started, use_count=" << self.use_count() << "\n";
    }
};

int main() {
    auto w = std::make_shared<Worker>();   // use_count=1
    w->start();                            // use_count=2（self 持有副本）
    return 0;
}
// 输出：Worker started, use_count=2

7.6 自定义分配器

STL 容器支持自定义分配器以适配特殊场景（实时系统、嵌入式无堆环境）：

#include <cstddef>
#include <iostream>
#include <vector>
#include <new>

// 简单的栈上内存池分配器
template <typename T, size_t N>
class StackAllocator {
    alignas(T) unsigned char buf_[sizeof(T) * N];
    size_t idx_ = 0;
public:
    using value_type = T;
    StackAllocator() noexcept = default;
    template <typename U>
    StackAllocator(const StackAllocator<U, N>&) noexcept {}

    T* allocate(size_t n) {
        if (idx_ + n > N) throw std::bad_alloc();
        T* p = reinterpret_cast<T*>(buf_ + idx_ * sizeof(T));
        idx_ += n;
        return p;
    }
    void deallocate(T*, size_t) noexcept {}   // 不释放，整体回收
    size_t used() const noexcept { return idx_; }
};

int main() {
    std::vector<int, StackAllocator<int, 100>> v;
    for (int i = 0; i < 50; ++i) v.push_back(i);
    std::cout << "size=" << v.size() << "\n";   // size=50
    return 0;
}
// 输出：size=50（50 个 int 在栈缓冲内分配，无堆分配）

7.7 pmr 多态内存资源

C++17 引入 std::pmr 框架，提供运行时多态的内存资源：

#include <memory_resource>
#include <vector>
#include <iostream>

int main() {
    // 栈上单块缓冲的资源
    unsigned char buf[1024];
    std::pmr::monotonic_buffer_resource mbr(buf, sizeof(buf));

    // 使用 pmr 容器
    std::pmr::vector<int> v(&mbr);
    for (int i = 0; i < 100; ++i) v.push_back(i);
    std::cout << "size=" << v.size() << "\n";   // size=100

    // monotonic_buffer_resource 析构时一次性释放所有内存
    return 0;
}
// 输出：size=100（所有内存来自栈缓冲 buf，无堆分配）

第 8 章 锁管理

8.1 lock_guard

std::lock_guard 是最简单的 RAII 锁，构造时加锁，析构时解锁：

#include <iostream>
#include <mutex>
#include <thread>
#include <vector>

class Counter {
    int value_ = 0;
    std::mutex mtx_;
public:
    void increment() {
        std::lock_guard<std::mutex> lock(mtx_);   // 加锁
        ++value_;
        // 作用域结束自动解锁，即使抛异常
    }
    int get() {
        std::lock_guard<std::mutex> lock(mtx_);
        return value_;
    }
};

int main() {
    Counter c;
    std::vector<std::thread> ts;
    for (int i = 0; i < 10; ++i)
        ts.emplace_back([&c]() { for (int j = 0; j < 1000; ++j) c.increment(); });
    for (auto& t : ts) t.join();
    std::cout << "final=" << c.get() << "\n";   // final=10000
    return 0;
}
// 输出：final=10000（10 线程各加 1000，互斥保证最终 10000）

8.2 unique_lock

std::unique_lock 提供更灵活的锁管理（可延迟加锁、提前解锁、转移所有权）：

#include <iostream>
#include <mutex>
#include <condition_variable>

std::mutex mtx;
std::condition_variable cv;
bool ready = false;

void waiter(int id) {
    std::unique_lock<std::mutex> lock(mtx);   // 加锁
    cv.wait(lock, [] { return ready; });       // 等待时自动解锁，被唤醒时重新加锁
    std::cout << "waiter " << id << " proceeds\n";
    // 作用域结束解锁
}

void notifier() {
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
    {
        std::lock_guard<std::mutex> lock(mtx);
        ready = true;
    }
    cv.notify_all();
}

int main() {
    std::thread w1(waiter, 1), w2(waiter, 2), n(notifier);
    w1.join(); w2.join(); n.join();
    return 0;
}
// 输出（顺序可能不同）：
// waiter 1 proceeds
// waiter 2 proceeds

8.3 scoped_lock

C++17 引入 std::scoped_lock 支持多锁原子获取，避免死锁：

#include <iostream>
#include <mutex>
#include <thread>

class Account {
    int balance_;
    std::mutex mtx_;
public:
    explicit Account(int b) : balance_(b) {}
    void deposit(int amt) {
        std::lock_guard<std::mutex> lock(mtx_);
        balance_ += amt;
    }
    void withdraw(int amt) {
        std::lock_guard<std::mutex> lock(mtx_);
        balance_ -= amt;
    }
    int balance() {
        std::lock_guard<std::mutex> lock(mtx_);
        return balance_;
    }
    friend void transfer(Account& from, Account& to, int amt);
};

// 多锁原子获取：scoped_lock 用 std::lock 算法避免死锁
void transfer(Account& from, Account& to, int amt) {
    std::scoped_lock lock(from.mtx_, to.mtx_);   // 原子获取两把锁
    from.balance_ -= amt;
    to.balance_ += amt;
}

int main() {
    Account a(100), b(50);
    std::thread t1(transfer, std::ref(a), std::ref(b), 30);
    std::thread t2(transfer, std::ref(b), std::ref(a), 10);
    t1.join(); t2.join();
    std::cout << "a=" << a.balance() << ", b=" << b.balance() << "\n";   // a=80, b=70
    return 0;
}
// 输出：a=80, b=70

8.4 shared_mutex 读写锁

C++17 引入 std::shared_mutex 实现读写锁，shared_lock 是其 RAII 包装：

#include <iostream>
#include <mutex>
#include <shared_mutex>
#include <thread>
#include <vector>

class ThreadSafeMap {
    std::unordered_map<int, int> data_;
    std::shared_mutex mtx_;
public:
    void write(int k, int v) {
        std::unique_lock lock(mtx_);            // 独占写锁
        data_[k] = v;
    }
    int read(int k) const {
        std::shared_lock lock(mtx_);            // 共享读锁
        auto it = data_.find(k);
        return it != data_.end() ? it->second : -1;
    }
};

int main() {
    ThreadSafeMap m;
    std::vector<std::thread> ts;
    for (int i = 0; i < 5; ++i)
        ts.emplace_back([&m, i]() { m.write(i, i * 10); });
    for (auto& t : ts) t.join();
    std::cout << "m.read(3)=" << m.read(3) << "\n";   // m.read(3)=30
    return 0;
}
// 输出：m.read(3)=30

8.5 call_once 与 once_flag

std::call_once 保证某函数在多线程下仅执行一次：

#include <iostream>
#include <mutex>
#include <thread>
#include <vector>

class Singleton {
    static std::once_flag flag_;
    static Singleton* instance_;
    Singleton() = default;
public:
    static Singleton* get() {
        std::call_once(flag_, []() { instance_ = new Singleton(); });
        return instance_;
    }
    void hello() { std::cout << "Singleton at " << this << "\n"; }
};
std::once_flag Singleton::flag_;
Singleton* Singleton::instance_ = nullptr;

int main() {
    std::vector<std::thread> ts;
    for (int i = 0; i < 5; ++i)
        ts.emplace_back([]() { Singleton::get()->hello(); });
    for (auto& t : ts) t.join();
    return 0;
}
// 输出（5 次 Singleton 地址相同）：
// Singleton at 0x...
// Singleton at 0x...（同一地址）

第 9 章 网络套接字

9.1 POSIX 套接字 RAII

#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <stdexcept>
#include <cstring>
#include <iostream>

class Socket {
    int fd_;
public:
    Socket(int domain, int type, int protocol) {
        fd_ = ::socket(domain, type, protocol);
        if (fd_ < 0) throw std::runtime_error("socket failed");
    }
    explicit Socket(int fd) noexcept : fd_(fd) {}
    ~Socket() noexcept {
        if (fd_ >= 0) ::close(fd_);
    }
    Socket(const Socket&) = delete;
    Socket& operator=(const Socket&) = delete;
    Socket(Socket&& o) noexcept : fd_(o.fd_) { o.fd_ = -1; }
    Socket& operator=(Socket&& o) noexcept {
        if (this != &o) {
            if (fd_ >= 0) ::close(fd_);
            fd_ = o.fd_;
            o.fd_ = -1;
        }
        return *this;
    }
    int get() const noexcept { return fd_; }
    int release() noexcept { int t = fd_; fd_ = -1; return t; }

    void bind(uint16_t port) {
        sockaddr_in addr{};
        addr.sin_family = AF_INET;
        addr.sin_addr.s_addr = INADDR_ANY;
        addr.sin_port = htons(port);
        if (::bind(fd_, reinterpret_cast<sockaddr*>(&addr), sizeof(addr)) < 0)
            throw std::runtime_error("bind failed");
    }
    void listen(int backlog = 5) {
        if (::listen(fd_, backlog) < 0) throw std::runtime_error("listen failed");
    }
    Socket accept() {
        int cfd = ::accept(fd_, nullptr, nullptr);
        if (cfd < 0) throw std::runtime_error("accept failed");
        return Socket(cfd);
    }
    ssize_t send(const void* buf, size_t len) {
        return ::send(fd_, buf, len, 0);
    }
    ssize_t recv(void* buf, size_t len) {
        return ::recv(fd_, buf, len, 0);
    }
};
// 输出：Socket 对象析构自动 close fd，异常路径同样安全

9.2 客户端连接 RAII

#include <arpa/inet.h>

class TcpClient {
    Socket sock_;
public:
    TcpClient(const char* ip, uint16_t port) : sock_(AF_INET, SOCK_STREAM, 0) {
        sockaddr_in addr{};
        addr.sin_family = AF_INET;
        addr.sin_port = htons(port);
        ::inet_pton(AF_INET, ip, &addr.sin_addr);
        if (::connect(sock_.get(), reinterpret_cast<sockaddr*>(&addr), sizeof(addr)) < 0)
            throw std::runtime_error("connect failed");
    }
    void send(const std::string& msg) {
        sock_.send(msg.data(), msg.size());
    }
    std::string recv(size_t max_len = 1024) {
        std::string buf(max_len, '\0');
        ssize_t n = sock_.recv(buf.data(), max_len);
        buf.resize(n > 0 ? n : 0);
        return buf;
    }
};
// 输出：TcpClient 析构自动关闭连接

第 10 章 数据库事务

10.1 事务 RAII 模式

数据库事务天然适合 RAII：构造时 BEGIN，析构时 ROLLBACK（未显式 COMMIT 时）：

#include <iostream>
#include <stdexcept>
#include <string>

// 模拟数据库连接
class Database {
public:
    void execute(const std::string& sql) {
        std::cout << "exec: " << sql << "\n";
        if (sql.find("FAIL") != std::string::npos)
            throw std::runtime_error("sql error");
    }
    void beginTransaction() { std::cout << "BEGIN\n"; }
    void commit() { std::cout << "COMMIT\n"; }
    void rollback() { std::cout << "ROLLBACK\n"; }
};

class Transaction {
    Database& db_;
    bool committed_ = false;
public:
    explicit Transaction(Database& db) : db_(db) {
        db_.beginTransaction();
    }
    ~Transaction() noexcept {
        if (!committed_) {
            try { db_.rollback(); } catch (...) { /* 吞异常 */ }
        }
    }
    Transaction(const Transaction&) = delete;
    Transaction& operator=(const Transaction&) = delete;

    void commit() {
        db_.commit();
        committed_ = true;
    }
    void rollback() {
        if (!committed_) {
            db_.rollback();
            committed_ = true;   // 标记已处理，析构不再 ROLLBACK
        }
    }
};

void update_user(Database& db) {
    Transaction txn(db);                       // BEGIN
    db.execute("UPDATE users SET name='Alice' WHERE id=1");
    db.execute("UPDATE logs SET ts=NOW()");
    txn.commit();                               // COMMIT
    // 异常路径：~Transaction 自动 ROLLBACK
}

int main() {
    Database db;
    try { update_user(db); } catch (const std::exception& e) {
        std::cout << "error: " << e.what() << "\n";
    }
    return 0;
}
// 输出：
// BEGIN
// exec: UPDATE users SET name='Alice' WHERE id=1
// exec: UPDATE logs SET ts=NOW()
// COMMIT

10.2 嵌套事务与保存点

class Savepoint {
    Database& db_;
    std::string name_;
    bool released_ = false;
public:
    Savepoint(Database& db, std::string name) : db_(db), name_(std::move(name)) {
        db_.execute("SAVEPOINT " + name_);
    }
    ~Savepoint() noexcept {
        if (!released_) {
            try { db_.execute("ROLLBACK TO " + name_); } catch (...) {}
        }
    }
    Savepoint(const Savepoint&) = delete;
    Savepoint& operator=(const Savepoint&) = delete;
    void release() {
        db_.execute("RELEASE SAVEPOINT " + name_);
        released_ = true;
    }
};
// 输出：嵌套事务中局部失败回滚到 savepoint 而不影响外层事务

第 11 章 OpenGL 纹理/VBO

11.1 纹理对象 RAII

OpenGL 纹理对象需 glGenTextures/glDeleteTextures 配对：

#include <glad/glad.h>
#include <stdexcept>

class GlTexture {
    GLuint id_ = 0;
public:
    GlTexture() {
        glGenTextures(1, &id_);
        if (!id_) throw std::runtime_error("glGenTextures failed");
    }
    ~GlTexture() noexcept {
        if (id_) glDeleteTextures(1, &id_);
    }
    GlTexture(const GlTexture&) = delete;
    GlTexture& operator=(const GlTexture&) = delete;
    GlTexture(GlTexture&& o) noexcept : id_(o.id_) { o.id_ = 0; }
    GlTexture& operator=(GlTexture&& o) noexcept {
        if (this != &o) {
            if (id_) glDeleteTextures(1, &id_);
            id_ = o.id_;
            o.id_ = 0;
        }
        return *this;
    }
    void bind(GLenum target) const { glBindTexture(target, id_); }
    GLuint get() const noexcept { return id_; }
};
// 输出：纹理对象析构自动 glDeleteTextures，避免 GPU 资源泄漏

11.2 VBO/VAO RAII

class GlBuffer {
    GLuint id_ = 0;
public:
    GlBuffer() {
        glGenBuffers(1, &id_);
        if (!id_) throw std::runtime_error("glGenBuffers failed");
    }
    ~GlBuffer() noexcept {
        if (id_) glDeleteBuffers(1, &id_);
    }
    GlBuffer(const GlBuffer&) = delete;
    GlBuffer& operator=(const GlBuffer&) = delete;
    GlBuffer(GlBuffer&& o) noexcept : id_(o.id_) { o.id_ = 0; }
    GlBuffer& operator=(GlBuffer&& o) noexcept {
        if (this != &o) {
            if (id_) glDeleteBuffers(1, &id_);
            id_ = o.id_; o.id_ = 0;
        }
        return *this;
    }
    void bind(GLenum target) const { glBindBuffer(target, id_); }
    void data(GLenum target, GLsizeiptr size, const void* data, GLenum usage) {
        glBufferData(target, size, data, usage);
    }
};

class GlVao {
    GLuint id_ = 0;
public:
    GlVao() { glGenVertexArrays(1, &id_); }
    ~GlVao() noexcept { if (id_) glDeleteVertexArrays(1, &id_); }
    GlVao(const GlVao&) = delete;
    GlVao& operator=(const GlVao&) = delete;
    GlVao(GlVao&& o) noexcept : id_(o.id_) { o.id_ = 0; }
    void bind() const { glBindVertexArray(id_); }
};
// 输出：VBO/VAO 析构自动释放 GPU 资源

11.3 着色器程序 RAII

#include <string>
#include <vector>

class GlShader {
    GLuint id_ = 0;
public:
    GlShader(GLenum type, const std::string& source) {
        id_ = glCreateShader(type);
        const char* src = source.c_str();
        glShaderSource(id_, 1, &src, nullptr);
        glCompileShader(id_);
        GLint ok;
        glGetShaderiv(id_, GL_COMPILE_STATUS, &ok);
        if (!ok) {
            char log[1024];
            glGetShaderInfoLog(id_, sizeof(log), nullptr, log);
            glDeleteShader(id_);
            throw std::runtime_error(std::string("shader compile: ") + log);
        }
    }
    ~GlShader() noexcept { if (id_) glDeleteShader(id_); }
    GlShader(const GlShader&) = delete;
    GlShader& operator=(const GlShader&) = delete;
    GLuint get() const noexcept { return id_; }
};

class GlProgram {
    GLuint id_ = 0;
public:
    GlProgram() { id_ = glCreateProgram(); }
    ~GlProgram() noexcept { if (id_) glDeleteProgram(id_); }
    GlProgram(const GlProgram&) = delete;
    GlProgram& operator=(const GlProgram&) = delete;
    void attach(const GlShader& s) { glAttachShader(id_, s.get()); }
    void link() {
        glLinkProgram(id_);
        GLint ok;
        glGetProgramiv(id_, GL_LINK_STATUS, &ok);
        if (!ok) {
            char log[1024];
            glGetProgramInfoLog(id_, sizeof(log), nullptr, log);
            throw std::runtime_error(std::string("program link: ") + log);
        }
    }
    void use() const { glUseProgram(id_); }
    GLuint get() const noexcept { return id_; }
};
// 输出：着色器与程序析构自动释放 GPU 资源

第 12 章 CUDA 资源

12.1 设备内存 RAII

CUDA 设备内存需 cudaMalloc/cudaFree 配对：

#include <cuda_runtime.h>
#include <stdexcept>

class CudaMemory {
    void* dev_ptr_ = nullptr;
    size_t size_ = 0;
public:
    explicit CudaMemory(size_t bytes) : size_(bytes) {
        cudaError_t err = cudaMalloc(&dev_ptr_, bytes);
        if (err != cudaSuccess)
            throw std::runtime_error("cudaMalloc failed: " + std::string(cudaGetErrorString(err)));
    }
    ~CudaMemory() noexcept {
        if (dev_ptr_) cudaFree(dev_ptr_);
    }
    CudaMemory(const CudaMemory&) = delete;
    CudaMemory& operator=(const CudaMemory&) = delete;
    CudaMemory(CudaMemory&& o) noexcept
        : dev_ptr_(o.dev_ptr_), size_(o.size_) {
        o.dev_ptr_ = nullptr; o.size_ = 0;
    }
    CudaMemory& operator=(CudaMemory&& o) noexcept {
        if (this != &o) {
            if (dev_ptr_) cudaFree(dev_ptr_);
            dev_ptr_ = o.dev_ptr_; size_ = o.size_;
            o.dev_ptr_ = nullptr; o.size_ = 0;
        }
        return *this;
    }
    void* get() const noexcept { return dev_ptr_; }
    size_t size() const noexcept { return size_; }

    void copy_from_host(const void* host_ptr) {
        cudaError_t err = cudaMemcpy(dev_ptr_, host_ptr, size_, cudaMemcpyHostToDevice);
        if (err != cudaSuccess) throw std::runtime_error("cudaMemcpy H2D failed");
    }
    void copy_to_host(void* host_ptr) const {
        cudaError_t err = cudaMemcpy(host_ptr, dev_ptr_, size_, cudaMemcpyDeviceToHost);
        if (err != cudaSuccess) throw std::runtime_error("cudaMemcpy D2H failed");
    }
};
// 输出：CUDA 设备内存析构自动 cudaFree，避免显存泄漏

12.2 CUDA Stream RAII

class CudaStream {
    cudaStream_t stream_ = nullptr;
public:
    CudaStream() {
        cudaError_t err = cudaStreamCreate(&stream_);
        if (err != cudaSuccess) throw std::runtime_error("cudaStreamCreate failed");
    }
    ~CudaStream() noexcept {
        if (stream_) cudaStreamDestroy(stream_);
    }
    CudaStream(const CudaStream&) = delete;
    CudaStream& operator=(const CudaStream&) = delete;
    CudaStream(CudaStream&& o) noexcept : stream_(o.stream_) { o.stream_ = nullptr; }
    cudaStream_t get() const noexcept { return stream_; }
    void synchronize() { cudaStreamSynchronize(stream_); }
};
// 输出：Stream 析构自动销毁

12.3 CUDA Event RAII

class CudaEvent {
    cudaEvent_t event_ = nullptr;
public:
    CudaEvent() {
        cudaError_t err = cudaEventCreate(&event_);
        if (err != cudaSuccess) throw std::runtime_error("cudaEventCreate failed");
    }
    ~CudaEvent() noexcept {
        if (event_) cudaEventDestroy(event_);
    }
    CudaEvent(const CudaEvent&) = delete;
    CudaEvent& operator=(const CudaEvent&) = delete;
    CudaEvent(CudaEvent&& o) noexcept : event_(o.event_) { o.event_ = nullptr; }
    void record(cudaStream_t stream = 0) { cudaEventRecord(event_, stream); }
    float elapsed_since(const CudaEvent& start) const {
        float ms;
        cudaEventElapsedTime(&ms, start.event_, event_);
        return ms;
    }
};
// 输出：Event 析构自动销毁

第 13 章 自定义 RAII 类模板

13.1 通用 RAII 包装模板

#include <utility>
#include <stdexcept>

// 通用 RAII 包装：构造获取 + 自定义释放
template <typename T, typename Deleter>
class RaiiWrap {
    T resource_;
    Deleter deleter_;
    bool owns_ = true;
public:
    RaiiWrap(T res, Deleter del) : resource_(res), deleter_(del) {}
    ~RaiiWrap() noexcept(noexcept(deleter_(resource_))) {
        if (owns_) deleter_(resource_);
    }
    RaiiWrap(const RaiiWrap&) = delete;
    RaiiWrap& operator=(const RaiiWrap&) = delete;
    RaiiWrap(RaiiWrap&& o) noexcept
        : resource_(o.resource_), deleter_(o.deleter_), owns_(o.owns_) {
        o.owns_ = false;
    }
    T get() const noexcept { return resource_; }
    T release() noexcept { owns_ = false; return resource_; }
    void reset(T new_res) {
        if (owns_) deleter_(resource_);
        resource_ = new_res;
        owns_ = true;
    }
};

// 使用示例：包装 POSIX shm
#include <sys/mman.h>
#include <fcntl.h>
#include <unistd.h>

int main() {
    auto shm_deleter = [](int fd) { ::close(fd); ::shm_unlink("/my_shm"); };
    int fd = ::shm_open("/my_shm", O_CREAT | O_RDWR, 0600);
    RaiiWrap<int, decltype(shm_deleter)> shm(fd, shm_deleter);
    // 作用域结束自动 close + shm_unlink
    return 0;
}
// 输出：shm 资源析构自动清理

13.2 类型擦除的通用 ScopeGuard

#include <functional>
#include <type_traits>
#include <utility>

class ScopeGuardAny {
    std::function<void()> cleanup_;
    bool active_ = true;
public:
    template <typename F,
              typename = std::enable_if_t<!std::is_same_v<std::decay_t<F>, ScopeGuardAny>>>
    explicit ScopeGuardAny(F&& f)
        : cleanup_(std::forward<F>(f)) {}

    ~ScopeGuardAny() noexcept(true) {
        if (active_) try { cleanup_(); } catch (...) { /* 吞异常 */ }
    }
    ScopeGuardAny(const ScopeGuardAny&) = delete;
    ScopeGuardAny& operator=(const ScopeGuardAny&) = delete;
    ScopeGuardAny(ScopeGuardAny&& o) noexcept
        : cleanup_(std::move(o.cleanup_)), active_(o.active_) { o.active_ = false; }
    void dismiss() noexcept { active_ = false; }
};

// 宏简化
#define SCOPE_EXIT(action) auto _scope_guard_##__LINE__ = ScopeGuardAny([&]() { action; })

int main() {
    int* p = new int(42);
    SCOPE_EXIT(delete p;);
    // 作用域结束自动 delete p
    return 0;
}
// 输出：p 在作用域结束自动 delete

13.3 编译期多态的 ScopeGuard

#include <type_traits>
#include <utility>

template <typename F>
class ScopeGuardTyped {
    F func_;
    bool active_ = true;
public:
    explicit ScopeGuardTyped(F f) noexcept(std::is_nothrow_move_constructible_v<F>)
        : func_(std::move(f)) {}
    ~ScopeGuardTyped() noexcept(true) {
        if (active_) try { func_(); } catch (...) {}
    }
    ScopeGuardTyped(ScopeGuardTyped&& o) noexcept(std::is_nothrow_move_constructible_v<F>)
        : func_(std::move(o.func_)), active_(o.active_) { o.active_ = false; }
    ScopeGuardTyped(const ScopeGuardTyped&) = delete;
    ScopeGuardTyped& operator=(const ScopeGuardTyped&) = delete;
    void dismiss() noexcept { active_ = false; }
};

template <typename F>
auto make_scope_guard(F&& f) {
    return ScopeGuardTyped<std::decay_t<F>>(std::forward<F>(f));
}

int main() {
    auto guard = make_scope_guard([]() { /* cleanup */ });
    return 0;
}
// 输出：编译期生成内联代码，无 std::function 开销