RAII

What problem does this section solve?

In C programming, we often encounter this type of code:

FILE* f = fopen("data.txt", "r");
// ... 使用文件 ...
fclose(f);  // 容易忘记！

If there's an early return in the middle or an exception is thrown, fclose won't execute, causing a resource leak. Similar issues arise with memory (malloc/free), locks (lock/unlock), sockets, and all other resources that require an "acquire-release" pattern.

RAII leverages the deterministic lifecycle of C++ objects to automatically manage resources, freeing you from manual cleanup.

What is this feature?

RAII (Resource Acquisition Is Initialization) is the most important resource management idiom in C++.

• Getting resources in the constructor.
• Release resources in the destructor.
• When an object goes out of scope, its destructor is always called.

This is one of the core design philosophies that distinguishes C++ from C and other languages, with smart pointers, lock_guard, and fstream being implementations of RAII.

C++ standard version

C++98 (RAII has existed since the inception of C++, with modern RAII tools like smart pointers and lock_guard maturing in C++11).

Required header files

RAII is a programming concept that does not require specific header files. However, the implementation of RAII is scattered in various places: <memory> (smart pointers), <mutex> (locks), <fstream> (file streams), etc.

Basic Syntax

class RAIIExample
{
    Resource* res;  // 管理的资源

public:
    RAIIExample() : res(获取资源) { }   // 构造：获取资源
    ~RAIIExample() { 释放资源; }        // 析构：释放资源
};

Common RAII Implementations

Example code

Example 1: Problems Without RAII vs. With RAII

#include <iostream>

// 模拟一个资源
class Resource
{
public:
    void open()  { std::cout << "Resource opened\n"; }
    void close() { std::cout << "Resource closed\n"; }
    void use()   { std::cout << "Resource used\n"; }
};

// ❌ 手动管理：容易忘记 close
void no_raii()
{
    Resource r;
    r.open();
    r.use();
    // 如果这里抛异常或提前 return，close 不会执行！
    r.close();
}

// ✅ RAII：利用析构函数自动释放
class ResourceGuard
{
    Resource& r;
public:
    ResourceGuard(Resource& res) : r(res)
    {
        r.open();  // 构造时获取资源
    }
    ~ResourceGuard()
    {
        r.close(); // 析构时释放资源
    }
};

void with_raii()
{
    Resource r;
    ResourceGuard guard(r);  // 构造时 open
    r.use();
    // guard 离开作用域，析构函数自动 close
}

int main()
{
    std::cout << "=== no_raii ===\n";
    no_raii();

    std::cout << "\n=== with_raii ===\n";
    with_raii();

    return 0;
}

Results：

=== no_raii ===
Resource opened
Resource used
Resource closed

=== with_raii ===
Resource opened
Resource used
Resource closed

Example 2: Building on Example 1, using lock_guard to understand RAII lock management

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

std::mutex mtx;  // 共享互斥量
int counter = 0;

// ❌ 手动加锁解锁（容易出问题）
void manual_lock()
{
    mtx.lock();
    ++counter;
    // 如果这里抛异常，unlock 永远不会被执行！
    mtx.unlock();
}

// ✅ RAII 风格：lock_guard 自动管理锁
void raii_lock()
{
    std::lock_guard<std::mutex> lock(mtx);  // 构造时 lock
    ++counter;
    // lock 离开作用域，析构函数自动 unlock
}

int main()
{
    std::thread t1([] {
        for (int i = 0; i < 1000; ++i)
            raii_lock();
    });
    std::thread t2([] {
        for (int i = 0; i < 1000; ++i)
            raii_lock();
    });

    t1.join();
    t2.join();

    std::cout << "counter = " << counter << " (expected 2000)\n";

    return 0;
}

Results：

counter = 2000 (expected 2000)

Example 3: Building on Example 2, understanding file RAII using fstream.

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

// RAII：fstream 在析构时会自动关闭文件
void write_and_read()
{
    // 写文件
    {
        std::ofstream out("raii_test.txt");
        out << "Hello RAII!\n";
        out << "This is line 2.\n";
        // out 离开作用域，文件自动关闭
    }

    // 读文件
    {
        std::ifstream in("raii_test.txt");
        std::string line;
        while (std::getline(in, line))
        {
            std::cout << line << "\n";
        }
        // in 离开作用域，文件自动关闭
    }
}

int main()
{
    write_and_read();
    std::cout << "File was automatically closed by RAII\n";
    return 0;
}

Results：

Hello RAII!
This is line 2.
File was automatically closed by RAII

Example 4: Building on Example 3, the value of RAII becomes apparent only when there's an early return.

This example deliberately simulates "discovering invalid data during processing and making an early return." In a normal flow, manual release and RAII look similar, but once there are multiple return paths, the difference becomes obvious.

#include <iostream>
#include <string>
#include <utility>
#include <vector>

class Connection
{
    std::string name_;

public:
    explicit Connection(std::string name) : name_(std::move(name))
    {
        std::cout << name_ << " connected\n";
    }

    ~Connection()
    {
        std::cout << name_ << " disconnected\n";
    }

    void send(const std::string& msg)
    {
        std::cout << name_ << " send: " << msg << "\n";
    }
};

bool upload_with_raii(const std::vector<std::string>& lines)
{
    Connection conn("server"); // 构造时连接，函数结束时自动断开

    for (const auto& line : lines)
    {
        if (line.empty())
        {
            std::cout << "empty line, stop upload\n";
            return false; // conn 仍然会析构
        }

        conn.send(line);
    }

    return true; // conn 也会析构
}

int main()
{
    std::vector<std::string> data = {"hello", "world", "", "after error"};

    bool ok = upload_with_raii(data);
    std::cout << "upload ok = " << std::boolalpha << ok << "\n";

    return 0;
}

Results：

server connected
server send: hello
server send: world
empty line, stop upload
server disconnected
upload ok = false

runtime results

See the "running results" for each example above.

Key syntax explanation in the example

|Here is the translation of the provided Simplified Chinese Markdown fragment into natural American English, following all specified rules.

Common Errors

Error 1: Throwing exceptions in destructors

~MyRAII()
{
    cleanup();  // 如果 cleanup 抛异常...
}

If a destructor throws an exception while another exception is already propagating, the program will simply crash. Destructors should be marked as noexcept and catch all exceptions.

Error 2: Creating RAII objects on the heap

auto* guard = new std::lock_guard<std::mutex>(mtx);  // ❌ 永远不会自动析构！

Correct practice: RAII objects must be created on the stack to leverage the characteristic of automatic destruction when going out of scope.

Error 3: Forgetting the scope of RAII objects

void func()
{
    std::lock_guard<std::mutex> lock(mtx);
    // 锁在这里面生效
}  // 离开作用域，解锁

// 在外面访问共享数据没有保护！

Best Practice: Ensure that shared data is accessed within the lock's scope.

使用建议

• 明确目标：在开始前确定您的具体需求，以便选择最合适的工具或教程。
• 充分利用资源：参考官方文档、教程和博客，这些资料能帮助您快速上手并解决问题。
• 实践应用：通过动手操作项目或编写代码来巩固学习成果，提升实际操作能力。
• 问题解决：遇到困难时，查阅参考资料或寻求社区支持，逐步培养独立解决问题的能力。
• 分享经验：完成项目后，可以撰写文章或博客分享心得，帮助其他学习者。

如果需要针对特定领域（如单片机、机器人或环境搭建）的进一步建议，请提供更多信息，我将为您细化内容。

1. "Use RAII for acquire/release pairs": This is the fundamental principle of resource management in C++.
2. Never manually new/delete, lock/unlock, open/close: use smart pointers, lock_guard, fstream.
3. RAII objects must be on the stack: Use scope to automatically trigger destruction.
4. Destructors must never throw exceptions: marked with noexcept.
5. Understanding RAII is to understand C++'s core design philosophy: later smart pointers and concurrent programming are all built upon RAII.
6. To control resource holding time using scope: If you want to release resources earlier, place the RAII object in a smaller {} scope.

Summary

• RAII = Resource Acquisition Is Initialization, is the most core resource management idiom in C++.
• Acquire resources at construction, release them at destruction, and guarantee release when leaving the scope.
• std::unique_ptr, std::lock_guard, and std::fstream are all RAII.
• The value of RAII is most apparent in cases with multiple return, exceptions, and complex branches.
• Never throw exceptions in destructors.
• Understanding RAII lays the foundation for comprehending smart pointers and concurrent programming.