C++ RAII

1. What is RAII?

RAII is a C++ programming idiom where resource allocation is tied to object lifetime.

• When an object is created (constructor), it acquires some resource (memory, file handle, mutex, network socket, etc.).
• When the object is destroyed (destructor), it releases the resource automatically.

In short:

“Acquire resource in constructor → Release resource in destructor”

---

2. Why do we need RAII?

In C++, managing resources manually can be error-prone:

void openFile(const std::string& filename) {
    FILE* f = fopen(filename.c_str(), "r");
    if (!f) return; // error handling    // Do something with file    fclose(f); // need to remember to close!
}

Problems here:

• If an exception occurs after fopen but before fclose, the file may never be closed → resource leak.
• Manual cleanup must be remembered everywhere → easy to make mistakes.

RAII solves this:

• Resource cleanup is automatic when the object goes out of scope.
• Exception-safe: no matter how the function exits, destructor releases the resource.

---

3. How RAII works

Key idea: Encapsulate the resource inside a class, and release it in the destructor.

#include <iostream>
#include <fstream>
#include <string>class FileRAII {
    std::ifstream file;
public:
    FileRAII(const std::string& filename) {
        file.open(filename);
        if (!file.is_open()) {
            throw std::runtime_error("Failed to open file");
        }
    }    ~FileRAII() {
        file.close(); // automatically called when object goes out of scope
        std::cout << "File closed automatically.\n";
    }    void readLine(std::string& line) {
        std::getline(file, line);
    }
};int main() {
    try {
        FileRAII f("example.txt");
        std::string line;
        f.readLine(line);
        std::cout << "First line: " << line << "\n";
        // No need to manually close the file
    } catch (const std::exception& e) {
        std::cout << "Error: " << e.what() << "\n";
    }
} 

What happens here:

1. FileRAII f("example.txt"); → constructor opens the file.
2. When main function exits (even if an exception occurs), ~FileRAII() automatically closes the file.
3. No manual cleanup is needed.

---

4. Common RAII use cases

1. Memory management

std::unique_ptr<int> ptr = std::make_unique<int>(42);
// memory freed automatically when ptr goes out of scope

2. File handles – std::ifstream / std::ofstream use RAII internally.
3. Mutex locking

std::mutex mtx;void safeFunction() {
    std::lock_guard<std::mutex> lock(mtx); // locks mutex
    // do something thread-safe
} // lock automatically released when lock goes out of scope

4. Database connections, sockets, graphics resources – any resource that needs proper cleanup.

---

5. Why RAII is important

• Automatic cleanup → no leaks.
• Exception-safe → resources released even on errors.
• Readable & maintainable → resource management is localized to the class.
• Promotes ownership semantics → you know exactly which object “owns” a resource.

---

6. Summary

Concept	Explanation
RAII	Tie resource lifetime to object lifetime.
Constructor	Acquires resource.
Destructor	Releases resource automatically.
Benefit	No manual cleanup, exception safe, reduces leaks.
Examples	Memory (unique_ptr), Files (ifstream), Mutex (lock_guard).

---

💡 Analogy:
Think of RAII like renting a locker with a smart lock: you put your stuff in (constructor), and when you leave, the locker automatically locks and returns your deposit (destructor). You don’t have to remember to lock it yourself.