C++ RAII (Resource Acquisition Is Initialization): The Core Philosophy

RAII (Resource Acquisition Is Initialization) is the single most important architectural idiom in the C++ programming language. Invented by Bjarne Stroustrup, it completely eliminates resource leaks without requiring a garbage collector.

C++ RAII Lifecycle Scope Entry Execution Scope Exit

Figure 8: The RAII Lifecycle: Constructor Resource Acquisition → Scope Exit Deterministic Destructor

Building a Custom RAII File Handle Wrapper

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

class SafeFile {
private:
    std::ofstream fileStream;
public:
    // 1. Acquire resource in constructor
    explicit SafeFile(const std::string& filename) {
        fileStream.open(filename);
        std::cout << "File opened successfully.\n";
    }

    // 2. Deterministically release resource in destructor
    ~SafeFile() {
        if (fileStream.is_open()) {
            fileStream.close();
            std::cout << "File closed deterministically on scope exit!\n";
        }
    }

    void writeLine(const std::string& text) {
        fileStream << text << "\n";
    }
};

int main() {
    {
        SafeFile log("audit.log");
        log.writeLine("User logged in at 10:00 AM");
    } // File is closed automatically right here! No manual close() needed!

    return 0;
}

Frequently Asked Questions (FAQ) - Student & Interview Review

Q1. What does RAII stand for and what is its core rule?

RAII stands for 'Resource Acquisition Is Initialization'. Its core rule is: Bind the lifecycle of any system resource (heap memory, file handles, network sockets, thread mutexes) to the lifetime of a local stack object. Acquire the resource in the constructor, and release it in the destructor.

Q2. Why does RAII guarantee exception safety in C++?

When an exception is thrown in C++, the runtime executes Stack Unwinding, which deterministically calls the destructors of all local stack objects in reverse order of construction. This guarantees resources are released even if a function terminates prematurely.