RAII、生命周期与拷贝移动：C++ 如何把资源释放写进类型

C++ 的核心不是 class 语法，而是对象生命周期。 构造函数建立不变量。 析构函数释放资源。 拷贝和移动决定所有权如何传播。 RAII 把资源释放从“记得调用 cleanup”变成“对象离开作用域自动执行析构”。 这就是 C++ 能在没有垃圾回收的前提下写出可靠资源管理代码的根基。

RAII 是资源协议的类型化

RAII 全称 Resource Acquisition Is Initialization。 更准确地说，它把资源获取绑定到对象初始化，把资源释放绑定到对象销毁。

class File {
public:
  explicit File(const char* path);
  ~File();

private:
  int fd_;
};

File 对象存在，文件描述符就有效。 File 对象析构，文件描述符就释放。 调用方不需要记住每个 return 分支都 close。 错误路径、异常路径和提前返回都会执行析构。

构造函数必须建立完整不变量

构造函数完成后，对象应该处于可使用状态。 如果资源获取失败，构造函数可以抛异常，或者使用工厂返回错误。 不要让“半初始化对象”泄漏出去。

class Buffer {
public:
  explicit Buffer(std::size_t n)
    : data_(new unsigned char[n]), size_(n) {}

  ~Buffer() { delete[] data_; }

private:
  unsigned char* data_;
  std::size_t size_;
};

这段代码展示了 RAII 思想，但现代 C++ 通常不手写裸 new[]。 应优先使用 std::vector、std::string、std::unique_ptr。 手写资源类型只在封装文件描述符、句柄、mmap、GPU 资源等场景必要。

析构函数是最后一道释放边界

析构函数应该释放资源，并尽量不抛异常。 析构过程如果抛异常，尤其在栈展开期间，可能导致程序终止。

class LockGuard {
public:
  explicit LockGuard(Mutex& m) : mutex_(m) { mutex_.lock(); }
  ~LockGuard() noexcept { mutex_.unlock(); }

private:
  Mutex& mutex_;
};

LockGuard 的意义不在于少写几行代码。 它把锁释放绑定到作用域。 函数出现多个返回点时，锁仍会释放。 这直接降低并发死锁风险。

Rule of Three 是资源类的最低警报

如果类手写析构函数，通常也要考虑拷贝构造和拷贝赋值。 否则编译器生成的浅拷贝可能复制资源句柄。

class BadBuffer {
public:
  explicit BadBuffer(std::size_t n) : p_(new char[n]) {}
  ~BadBuffer() { delete[] p_; }

private:
  char* p_;
};

BadBuffer a(10); BadBuffer b = a; 会复制指针值。 两个对象析构时都会 delete[] 同一地址。 这就是 double-free。

Rule of Five 管住移动语义

C++11 引入移动语义后，资源类还要考虑移动构造和移动赋值。 移动不是字节复制。 移动是把资源所有权从源对象转移到目标对象，并让源对象保持可析构状态。

class Buffer {
public:
  explicit Buffer(std::size_t n) : p_(new char[n]), size_(n) {}
  ~Buffer() { delete[] p_; }

  Buffer(const Buffer&) = delete;
  Buffer& operator=(const Buffer&) = delete;

  Buffer(Buffer&& other) noexcept
    : p_(other.p_), size_(other.size_) {
    other.p_ = nullptr;
    other.size_ = 0;
  }

  Buffer& operator=(Buffer&& other) noexcept {
    if (this != &other) {
      delete[] p_;
      p_ = other.p_;
      size_ = other.size_;
      other.p_ = nullptr;
      other.size_ = 0;
    }
    return *this;
  }

private:
  char* p_ = nullptr;
  std::size_t size_ = 0;
};

noexcept 很关键。 标准容器在扩容时更愿意使用不会抛异常的移动构造。 如果移动可能抛，容器可能退回拷贝或放弃强异常保证。

Rule of Zero 是现代 C++ 的目标

手写析构、拷贝和移动容易出错。 如果成员类型已经能管理资源，就让编译器生成特殊成员函数。

class Image {
public:
  explicit Image(std::vector<std::byte> pixels)
    : pixels_(std::move(pixels)) {}

private:
  std::vector<std::byte> pixels_;
};

std::vector 自己管理内存。 Image 不需要写析构函数。 这就是 Rule of Zero。 真正的工程质量不是到处手写五个函数，而是把资源封装在最小的底层类型中，上层组合它们。

对象生命周期不是存储生命周期

一段存储可以存在，但对象生命周期未开始或已结束。 placement new、union、allocator 都会遇到这个边界。

alignas(T) unsigned char storage[sizeof(T)];
T* p = new (storage) T();
p->~T();

storage 一直存在。 T 对象只在 placement new 到析构之间存在。 析构后继续访问 *p 是生命周期错误。 这类代码常出现在容器、内存池和底层运行时里。

值语义和所有权语义要分清

std::string、std::vector 具有值语义。 拷贝它们会得到独立值。 std::unique_ptr 具有独占所有权。 它不能拷贝，只能移动。 std::shared_ptr 具有共享所有权。 它通过引用计数延长对象生命周期。

裸指针适合非拥有观察。 拥有资源时应优先使用 RAII 类型。

异常安全是生命周期的压力测试

异常会让控制流跳过普通语句。 RAII 的价值在这里最明显。

void process(Mutex& mutex, File& file) {
  std::lock_guard<Mutex> lock(mutex);
  file.write("begin");
  may_throw();
  file.write("end");
}

如果 may_throw 抛异常，lock 仍然析构。 锁仍然释放。 这比手动 unlock 更可靠。

异常安全通常分三层：

• 基本保证：对象仍可析构，不泄漏。
• 强保证：操作失败后状态不变。
• 不抛保证：操作不会抛异常。

资源类析构应接近不抛保证。

析构顺序是设计工具

成员析构顺序与声明顺序相反。 基类和成员析构也有固定规则。 可以利用这个规则表达依赖。

class Session {
private:
  Logger logger_;
  Connection connection_;
  Transaction transaction_;
};

析构时先析构 transaction_，再析构 connection_，最后析构 logger_。 如果事务依赖连接，连接依赖日志，这个顺序合理。 成员声明顺序不是排版问题，而是资源释放顺序。

移动后对象必须可析构

移动后的对象处于有效但未指定状态。 你不能假设它保留原值。 但它必须可以析构、赋值和满足类型文档承诺。

std::string a = "hello";
std::string b = std::move(a);
// a 仍可析构，也可重新赋值，但不要依赖它仍是 "hello"。

自定义类型移动后应给源对象一个简单状态。 通常是空指针、零大小或默认句柄。

跨语言边界不要泄漏 C++ 生命周期

C ABI 调用方不知道 C++ 构造、析构、异常和模板。 跨语言边界应把 C++ 对象包在不透明句柄里。

extern "C" Engine* engine_create();
extern "C" void engine_destroy(Engine*) noexcept;

内部可以用 RAII。 外部用显式 create/destroy。 边界层负责捕获异常、转换错误码、记录审计日志。

诊断生命周期错误

常见工具：

• ASan 查释放后使用和越界。
• UBSan 查非法转换和生命周期附近的 UB。
• LeakSanitizer 查泄漏。
• 静态分析查返回局部地址和双重释放路径。
• 单元测试覆盖异常路径。
• fuzz 覆盖组合输入。

c++ -std=c++23 -g -O1 \
  -fsanitize=address,undefined \
  -fno-omit-frame-pointer \
  buffer_test.cpp

工具不会替你设计所有权。 它们负责让错误路径可观测。

工程清单

• 资源获取后立即放进 RAII 类型。
• 拥有资源的类型禁止默认浅拷贝。
• 移动构造和移动赋值尽量 noexcept。
• 优先 Rule of Zero。
• 析构函数不抛异常。
• 成员声明顺序表达释放依赖。
• 裸指针只表达借用，不表达所有权。
• 跨 ABI 边界捕获异常。
• 异常路径测试和正常路径同等重要。
• 对资源释放日志保留审计字段。

小结

C++ 的对象模型让资源释放成为类型系统的一部分。 RAII 不是风格，而是把错误路径、异常路径和提前返回统一收束到析构函数。 掌握生命周期、拷贝、移动和析构顺序，才能写出既高性能又可观测的 C++ 工程代码。