Memory Management & RAII in C++

Resource Acquisition Is Initialization (RAII)

RAII is one of the most important idioms in C++. It ensures that resources are properly managed by tying resource lifetime to object lifetime. When an object is created, it acquires resources. When it's destroyed, it automatically releases them.

Core Principles

1. Acquire resources in constructors
2. Release resources in destructors
3. Let scope management handle cleanup
4. Exception safety comes automatically

void riskyFunction() {
    FILE* file = fopen("data.txt", "r");
    int* buffer = new int[1000];
    mutex.lock();
    
    try {
        // Work with resources
        if (error_condition) {
            // Must remember to clean up!
            fclose(file);
            delete[] buffer;
            mutex.unlock();
            throw std::runtime_error("Error");
        }
        
        // More code...
    } catch (...) {
        // Cleanup in catch too!
        fclose(file);
        delete[] buffer;
        mutex.unlock();
        throw;
    }
    
    // And again at the end
    fclose(file);
    delete[] buffer;
    mutex.unlock();
}

void safeFunction() {
    std::ifstream file("data.txt");
    std::vector<int> buffer(1000);
    std::lock_guard<std::mutex> lock(mutex);
    
    // Work with resources
    if (error_condition) {
        throw std::runtime_error("Error");
        // No manual cleanup needed!
    }
    
    // More code...
    
} // All resources automatically released here

Why RAII Matters

Without RAII

void riskyFunction() {
    Resource* res = acquireResource();
    
    // If exception occurs here...
    doSomething(); 
    
    // This cleanup might never execute!
    releaseResource(res);
}

With RAII

class ResourceWrapper {
    Resource* res;
public:
    ResourceWrapper() : res(acquireResource()) {}
    ~ResourceWrapper() { releaseResource(res); }
};

void safeFunction() {
    ResourceWrapper wrapper;
    // Resource automatically cleaned up
    // even if exception occurs!
    doSomething();
} // Destructor called here

RAII in the Standard Library

The C++ standard library extensively uses RAII:

• std::vector: Manages dynamic arrays
• std::string: Manages character buffers
• std::fstream: Manages file handles
• std::lock_guard: Manages mutex locks
• std::unique_ptr: Manages heap objects

Benefits of RAII

1. Automatic cleanup: No manual resource management
2. Exception safety: Resources released even during exceptions
3. Deterministic destruction: Objects destroyed in reverse order
4. No memory leaks: Impossible to forget cleanup
5. Cleaner code: Focus on logic, not resource management

Stack Unwinding

When an exception is thrown, C++ performs "stack unwinding":

1. Current function stops executing
2. Local objects are destroyed in reverse order
3. Destructors are called automatically
4. Process continues up the call stack
5. RAII ensures all resources are cleaned up

This makes C++ exception handling both safe and efficient.