Resource Acquisition Is Initialization

Resource Acquisition Is Initialization (RAII) is a programming idiom in C++ where resource acquisition and release are tied to an object's lifetime. A resource is acquired during object construction and automatically released when the object is destroyed.

• Ensures automatic resource management.
• Prevents resource leaks and improves exception safety.
• Acquires resources in constructors and releases them in destructors.

Resource Management Without RAII

Before understanding RAII, let's see the problems that arise when resources are managed manually.

• Resources such as files, memory, sockets, and mutexes require explicit cleanup.
• Forgetting to release a resource can lead to leaks and undefined behavior.
• Exception handling makes manual cleanup more error-prone.

Consider writing to a log file using a file descriptor:

void WriteToLog(int log_fd, const std::string& event)
{
    // write event
}

int main()
{
    int log_fd = open("/tmp/log", O_RDWR);

    if (log_fd < 0) {
        return -1;
    }

    WriteToLog(log_fd, "Event1");
    WriteToLog(log_fd, "Event2");

    // Forgot to close log_fd
    return 0;
}

In this example, the file descriptor is never closed, resulting in a resource leak.

Applying RAII

RAII solves this problem by placing resource acquisition and cleanup inside a class.

class Logger {
public:
    explicit Logger(const std::string& path)
    {
        log_fd_ = open(path.c_str(), O_RDWR);
    }

    void Log(const std::string& event)
    {
        // write event
    }

    ~Logger()
    {
        close(log_fd_);
    }

private:
    int log_fd_;
};

Now the resource is automatically released when the object goes out of scope.

int main()
{
    Logger logger("/tmp/log");
    logger.Log("Event");

    return 0;
}

Even if an exception occurs, the destructor executes and the file descriptor is closed.

Handling Resource Acquisition Failure

Sometimes resource acquisition may fail, and such failures must be communicated safely.

• Constructors cannot return error codes.
• Factory functions can be used to report acquisition failures.
• Smart pointers such as std::unique_ptr are commonly used for this purpose.

class Logger {
public:
    static std::unique_ptr<Logger>
    Create(const std::string& path)
    {
        int fd = open(path.c_str(), O_RDWR);

        if (fd < 0)
            return nullptr;

        return std::unique_ptr<Logger>(
            new Logger(fd));
    }

    ~Logger()
    {
        close(log_fd_);
    }

private:
    explicit Logger(int fd)
        : log_fd_(fd)
    {
    }

    int log_fd_;
};

This approach allows the caller to detect resource acquisition failures immediately.

RAII and Exception Safety

One of the major advantages of RAII is that resources are released automatically during exception handling.

• Destructors are invoked during stack unwinding.
• Resources are cleaned up even when exceptions occur.
• Manual cleanup code becomes unnecessary.

Applications of RAII

RAII is widely used in modern C++ resource management.

Thread Management

RAII can automatically manage thread cleanup.

• Prevents forgotten join() or detach() calls.
• Ensures thread cleanup during exceptions.

Without RAII

std::thread t(func);

// exception occurs

t.join();   // never reached

If an exception occurs before join(), the program may terminate unexpectedly.

A simple RAII wrapper solves this problem:

class ThreadGuard {
private:
    std::thread& t;

public:
    explicit ThreadGuard(std::thread& thread)
        : t(thread)
    {
    }

    ~ThreadGuard()
    {
        if (t.joinable())
            t.join();
    }
};

Usage:

std::thread t(func);
ThreadGuard guard(t);

The thread is automatically joined when the guard object goes out of scope.

Smart Pointers

Modern C++ uses smart pointers as one of the most common examples of RAII.

{
    std::unique_ptr<int> ptr =
        std::make_unique<int>(10);

} // memory automatically released

Smart pointers eliminate the need for manual new and delete, preventing memory leaks.

Common RAII-based smart pointers include:

• std::unique_ptr
• std::shared_ptr
• std::weak_ptr

Advantages of RAII

RAII provides several benefits that improve resource management in C++ programs:

• Prevents resource leaks by automatically releasing resources.
• Ensures proper cleanup even when exceptions occur.
• Simplifies resource management by associating it with object lifetime.
• Improves code reliability and maintainability.

Limitations of RAII

Although powerful, RAII has some limitations:

• Requires careful class and resource wrapper design.
• Resource acquisition failures need separate handling.
• May increase the number of helper classes.
• Can be difficult to apply to shared or global resources.