RAII 的原理、应用及 ScopeExit 的妙用 #

RAII 基本概念 #

RAII（Resource Acquisition Is Initialization）即资源获取即初始化，是 C++ 中一种重要的资源管理机制。其核心思想是将资源的生命周期与对象的生命周期绑定，通过类的构造函数获取资源，在析构函数中释放资源。这样可以确保资源在变量超出作用域时自动释放，避免资源泄漏和错误使用。

RAII 的应用场景 #

管理内存 #

使用智能指针如 std::unique_ptr 可以自动管理内存，避免内存泄漏：

#include <memory>
void foo() {
    std::unique_ptr<int> p(new int(42));
    // ...
} // p 被销毁，自动释放内存

自定义类管理内存：

class MemoryBlock {
public:
    MemoryBlock(size_t size) {
        data = new char[size];
        std::cout << "Memory block allocated.\n";
    }
    ~MemoryBlock() {
        delete[] data;
        std::cout << "Memory block deallocated.\n";
    }
private:
    char* data;
};
void someFunc() {
    MemoryBlock block(1024);
    // 使用 block.data 进行内存操作
}

管理文件句柄 #

使用 std::fstream 自动管理文件句柄：

#include <fstream>
void foo() {
    std::fstream file("example.txt");
    if (file.is_open()) {
        // ...
    }
    // file 被销毁，自动关闭文件句柄
}

自动计时器 #

使用 RAII 实现自动计时器：

class Timer {
public:
    Timer(std::string label)
        : start(std::chrono::high_resolution_clock::now()),
          label(label) {}
    ~Timer() {
        auto end = std::chrono::high_resolution_clock::now();
        auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
        std::cout << label << " took " << duration.count() << " ms.\n";
    }
private:
    std::chrono::time_point<std::chrono::high_resolution_clock> start;
    std::string label;
};
void someFunc() {
    Timer timer("someFunc");
    // do something...
}

管理网络连接 #

使用自定义类管理网络连接：

class Connection {
public:
    Connection() {
        // 获取网络连接
    }
    ~Connection() {
        // 释放网络连接
    }
    // ...
};
void foo() {
    Connection conn;
    // ...
} // conn 被销毁，自动释放网络连接

RAII 的巧用：ScopeExit #

什么是 ScopeExit #

ScopeExit 是一种利用 RAII 特性的机制，可以在作用域结束时自动执行清理操作。它类似于智能指针，但更加灵活，不需要自定义删除函数。

使用示例 #

没有 ScopeExit 的代码：

void test() {
    char *test = new char[100];
    if (a) {
        delete[] test; // 需要多次显式释放资源
        return;
    }
    // ...
    if (b) {
        delete[] test;
        return;
    }
    // ...
    delete[] test;
}

使用 ScopeExit 的代码：

void test() {
    char *test = new char[100];
    std::ofstream ofs("test.txt");
    ScopeExit {
        delete[] test; // 在作用域结束时自动释放资源
        ofs.close();   // 在作用域结束时自动关闭文件
    };
    if (a) {
        return;
    }
    // ...
    if (b) {
        return;
    }
    // ...
}

ScopeExit 的实现 #

基于 C++11 的 ScopeExit 实现：

class ScopeExit {
public:
    ScopeExit() = default;
    ScopeExit(const ScopeExit&) = delete;
    void operator=(const ScopeExit&) = delete;
    ScopeExit(ScopeExit&&) = default;
    ScopeExit& operator=(ScopeExit&&) = default;

    template <typename F, typename... Args>
    ScopeExit(F&& f, Args&&... args) {
        func_ = std::bind(std::forward<F>(f), std::forward<Args>(args)...);
    }

    ~ScopeExit() {
        if (func_) {
            func_();
        }
    }

private:
    std::function<void()> func_;
};

#define _CONCAT(a, b) a##b
#define _MAKE_SCOPE_(line) ScopeExit _CONCAT(defer, line) = [&]()
#define SCOPE_GUARD _MAKE_SCOPE_(__LINE__)

使用方式：

void test() {
    char *test = new char[100];
    std::ofstream ofs("test.txt");
    SCOPE_GUARD {
        delete[] test;
        ofs.close();
    };
    if (a) {
        return;
    }
    // ...
    if (b) {
        return;
    }
    // ...
}

总结 #

RAII 的核心思想是通过对象的生命周期来管理资源，从而避免资源泄漏和错误使用的问题，提高代码的可读性、可维护性和健壮性。ScopeExit 是 RAII 的一种高级应用，可以在作用域结束时自动执行清理操作，使代码更加简洁和安全。