第1章：资源管理安全——RAII与资源泄漏预防

资源管理，说白了就是管好你程序里借来的东西。内存、文件句柄、网络连接、互斥锁……这些都是资源。借了不还，程序就会出问题。我见过太多线上事故，根源就是资源泄漏。

1.1 资源泄漏：一个老生常谈的问题

先看一个经典的反面教材：

void processData(const char* filename) {
    FILE* file = fopen(filename, "r");
    if (!file) return;

    char* buffer = new char[1024];
    // 处理数据...
    if (someError) {
        // 忘记释放 buffer 和关闭 file
        return;  // 资源泄漏！
    }

    delete[] buffer;
    fclose(file);
}

这段代码的问题很明显：someError 为真时，buffer 没释放，file 没关闭。你可能觉得「谁会写这么蠢的代码？」——嗯，我当年也这么想，直到我在一个大型项目中看到类似的代码跑了三年都没人发现。

1.2 RAII：C++ 资源管理的基石

RAII（Resource Acquisition Is Initialization）是 C++ 独有的资源管理哲学。它的核心思想很简单：把资源的生命周期绑定到对象的生命周期上。

构造函数获取资源，析构函数释放资源。就这么简单。

class FileGuard {
public:
    explicit FileGuard(const char* filename) 
        : file_(fopen(filename, "r")) {
        if (!file_) {
            throw std::runtime_error("无法打开文件");
        }
    }

    ~FileGuard() {
        if (file_) {
            fclose(file_);
        }
    }

    // 禁止拷贝
    FileGuard(const FileGuard&) = delete;
    FileGuard& operator=(const FileGuard&) = delete;

    // 允许移动
    FileGuard(FileGuard&& other) noexcept 
        : file_(other.file_) {
        other.file_ = nullptr;
    }

    FILE* get() const { return file_; }

private:
    FILE* file_;
};

有了这个类，前面的代码可以改写成：

void processData(const char* filename) {
    FileGuard file(filename);  // 构造时打开文件
    auto buffer = std::make_unique<char[]>(1024);

    // 处理数据...
    if (someError) {
        return;  // 安全！析构函数会自动关闭文件
    }
    // 正常退出也会自动关闭
}

我个人习惯：能用 RAII 的地方，绝不用手动管理。这不是偷懒，是降低心智负担。

1.3 句柄与描述符管理

文件句柄、socket 描述符、Windows 的 HANDLE……这些系统资源比内存更危险。为什么？因为系统对句柄数量有限制。泄漏一个句柄，可能影响整个进程甚至整个系统。

资源类型	获取方式	释放方式	常见泄漏场景
文件句柄	fopen()	fclose()	异常路径未关闭
Socket	socket()	close()	网络错误时忘记关闭
互斥锁	pthread_mutex_lock()	pthread_mutex_unlock()	加锁后抛出异常
Windows HANDLE	CreateFile()	CloseHandle()	多路径返回忘记释放

我曾经接手过一个网络服务，运行一周后就会卡死。查了半天，发现是某个异常处理分支忘记 close() socket 描述符。系统默认的 fd 上限是 1024，泄漏到 1023 个时，新连接就进不来了。

1.4 自定义资源管理类

标准库提供了 std::unique_ptr、std::shared_ptr、std::lock_guard 等 RAII 封装。但有些资源没有现成的封装，比如自定义的硬件句柄、第三方库的资源。

这时候就需要自己写 RAII 包装类。我总结了一个模板：

template<typename Traits>
class ResourceGuard {
public:
    using Handle = typename Traits::Handle;

    explicit ResourceGuard(Handle handle) 
        : handle_(handle), valid_(true) {}

    ~ResourceGuard() {
        if (valid_) {
            Traits::close(handle_);
        }
    }

    // 移动语义
    ResourceGuard(ResourceGuard&& other) noexcept
        : handle_(other.handle_), valid_(other.valid_) {
        other.valid_ = false;
    }

    Handle get() const { return handle_; }
    bool is_valid() const { return valid_; }

    // 禁止拷贝
    ResourceGuard(const ResourceGuard&) = delete;
    ResourceGuard& operator=(const ResourceGuard&) = delete;

private:
    Handle handle_;
    bool valid_;
};

// 使用示例：封装 POSIX 文件描述符
struct FileDescriptorTraits {
    using Handle = int;
    static void close(Handle fd) {
        if (fd >= 0) {
            ::close(fd);
        }
    }
};

using FileDescriptorGuard = ResourceGuard<FileDescriptorTraits>;

这个模板的好处是：你只需要定义 Handle 类型和 close 函数，就能得到一个完整的 RAII 封装。我把它用在了很多项目中，包括数据库连接、GPU 资源、加密上下文等。

1.5 避坑指南

讲几个我踩过的坑：

• 析构函数不要抛异常。如果析构函数抛异常，程序会直接 terminate。释放资源时如果可能失败，要么吞掉异常，要么记录日志。
• 移动语义要正确实现。移动后源对象要置为「空」状态，否则两个对象会争抢同一个资源。
• 注意资源获取的中间状态。如果一个类需要获取多个资源，获取过程中失败怎么办？我建议用「二阶段构造」或者用 std::optional 包装。

1.6 知识体系总览

下面这张图总结了本章的核心内容：

这张图把资源管理拆成了四个维度：RAII 是理论基础，资源泄漏预防是实战目标，句柄管理是具体场景，自定义类是扩展手段。四者缺一不可。

好了，第一章就讲到这里。资源管理是 C++ 安全编程的基石，后面的章节会在这个基础上深入更多细节。

---