C++ 中的 RAII 与智能指针：资源安全的最佳实践

作者

在 C++ 代码中，手动管理资源是一项既痛苦又容易出错的任务。无论是文件句柄、网络连接还是内存块，忘记释放资源都可能导致内存泄漏、文件描述符耗尽甚至安全漏洞。自从 C++98 之后，标准库就提供了几种工具来缓解这一痛点，其中最核心的技术是 RAII（Resource Acquisition Is Initialization）与智能指针。本文将通过实例演示 RAII 的基本原理，比较 std::unique_ptr、std::shared_ptr 与 std::weak_ptr 的使用场景，并给出常见陷阱的避免技巧。

1. RAII 的核心思想

RAII 的核心思想是：资源的获取与对象的生命周期绑定。当对象被创建时，资源被获取；当对象销毁时，资源被释放。这样，异常抛出或提前返回都不再导致资源泄漏，因为 C++ 的对象销毁会自动调用析构函数。 

class FileHandle {
public:
    explicit FileHandle(const std::string& path) : fp_(std::fopen(path.c_str(), "r")) {
        if (!fp_) throw std::runtime_error("Cannot open file");
    }
    ~FileHandle() { if (fp_) std::fclose(fp_); }
    // 禁止拷贝
    FileHandle(const FileHandle&) = delete;
    FileHandle& operator=(const FileHandle&) = delete;
    // 允许移动
    FileHandle(FileHandle&& other) noexcept : fp_(other.fp_) { other.fp_ = nullptr; }
    FileHandle& operator=(FileHandle&& other) noexcept {
        if (this != &other) {
            if (fp_) std::fclose(fp_);
            fp_ = other.fp_;
            other.fp_ = nullptr;
        }
        return *this;
    }
    FILE* get() const { return fp_; }
private:
    FILE* fp_;
};

上述代码中，FileHandle 对象在构造时打开文件，析构时关闭文件。无论是正常返回、异常抛出还是函数提前退出，FileHandle 的析构都会被调用，资源安全得到保障。

2. 智能指针：自动化的 RAII

C++11 引入了三种智能指针，分别解决了不同的所有权模型。

2.1 std::unique_ptr：独占所有权

unique_ptr 对象在任何时刻只能被一个指针持有。它是实现独占资源的最轻量级方式。 

std::unique_ptr<int[]> arr(new int[100]);   // 自动销毁数组

注意：unique_ptr 的构造需要传入对应的删除器（delete 或 delete[]）。
小技巧：如果你需要在函数间传递指针且不想复制，使用 std::move。 

std::unique_ptr <MyClass> p1 = std::make_unique<MyClass>();
std::unique_ptr <MyClass> p2 = std::move(p1); // p1 变空，p2 拥有资源

2.2 std::shared_ptr：共享所有权

当多个对象需要共享同一资源时，shared_ptr 通过引用计数实现。 

std::shared_ptr <Node> left = std::make_shared<Node>();
std::shared_ptr <Node> right = left; // 引用计数 +1

陷阱：循环引用会导致资源永远不释放。
解决：在循环引用处使用 std::weak_ptr。

2.3 std::weak_ptr：非拥有引用

weak_ptr 不增加引用计数，主要用来观察对象而不保持所有权。 

std::shared_ptr <Node> node = std::make_shared<Node>();
std::weak_ptr <Node> weakNode = node;   // 只观察

// 使用时需转换为 shared_ptr
if (auto shared = weakNode.lock()) {
    // 资源还存活
}

3. 组合使用：案例分析

假设我们有一个图数据结构，每个节点可能引用其父节点与子节点。使用 shared_ptr 直接实现父子指针会产生循环引用，导致内存泄漏。我们可以让父节点拥有子节点，用 shared_ptr，让子节点持有父节点，用 weak_ptr。 

struct Node {
    int value;
    std::vector<std::shared_ptr<Node>> children; // 独占子节点
    std::weak_ptr <Node> parent;                  // 观察父节点

    Node(int v) : value(v) {}
};

创建节点时：

auto root = std::make_shared <Node>(0);
auto child = std::make_shared <Node>(1);
child->parent = root;          // weak 赋值
root->children.push_back(child);

这样，root 的引用计数为 1，child 的引用计数为 2（root->children 与 root 对 child 的引用）。当 root 失去外部引用时，child 的引用计数降为 1；随后 root 的子节点容器被销毁，计数降为 0，child 被释放，整个图被正确回收。

4. 常见误区与最佳实践

误区 说明 解决方案
手动 delete 后仍保留指针 可能导致悬空指针、重复删除 使用智能指针，或者手动 delete 后立即置 nullptr
忽略异常安全 new 后出现异常导致资源泄漏 RAII：在构造函数中获取资源，析构释放
使用 new[] 与 delete 混用 访问越界、未对齐 用 std::vector 或 std::unique_ptr<T[]> 代替
循环引用 shared_ptr 互相持有 使用 weak_ptr 或设计无循环结构
不合适的删除器 unique_ptr 用 delete[] 释放单个对象 明确使用 std::default_delete<T[]> 或自定义删除器

5. 结语

RAII 与智能指针是现代 C++ 开发中不可或缺的安全工具。它们通过对象生命周期管理资源，消除了手工 malloc/free 或 new/delete 的繁琐与危险。熟练掌握 unique_ptr、shared_ptr 与 weak_ptr 的使用原则，并结合异常安全编程，可大幅提升代码质量与可维护性。希望本文能帮助你在日常编码中更自如地运用这些技巧。

发表评论