C++ Interview Questions

RAII (Resource Acquisition Is Initialization) is a programming idiom used in C++ to manage resources such as memory, file handles, and network connections. The idea behind RAII is that resource allocation is tied to the lifetime of objects: resources are acquired during object creation (initialization) and released during object destruction. This ensures that resources are properly cleaned up when they are no longer needed, even in the presence of exceptions.

Benefits of RAII:

1. Automatic Resource Management: Resources are automatically released when objects go out of scope, reducing the risk of resource leaks.
2. Exception Safety: RAII ensures that resources are properly cleaned up even if an exception is thrown, providing strong exception safety guarantees.
3. Simplified Code: By tying resource management to object lifetimes, RAII simplifies resource management logic, making the code easier to write, read, and maintain.
4. Scope-Bound Resource Management: Resources are bound to the scope of objects, ensuring that resources are released as soon as they are no longer needed.

Example 1: Managing Dynamic Memory:
Using RAII to manage dynamic memory with std::unique_ptr.

#include <memory>
#include <iostream>

class Resource {
public:
    Resource() { std::cout << "Resource Acquired\n"; }
    ~Resource() { std::cout << "Resource Released\n"; }
    void use() { std::cout << "Using Resource\n"; }
};

void useResource() {
    std::unique_ptr<Resource> resPtr = std::make_unique<Resource>();
    resPtr->use();
    // Resource is automatically released when resPtr goes out of scope
}

int main() {
    useResource();
    return 0;
}

In this example, std::unique_ptr manages the lifetime of a Resource object. The resource is acquired when resPtr is created and released when resPtr goes out of scope, ensuring proper cleanup.

Example 2: Managing File Handles:
Using RAII to manage file handles with a custom RAII class.

#include <fstream>
#include <iostream>

class FileHandle {
private:
    std::fstream file;
public:
    FileHandle(const std::string& filename) {
        file.open(filename, std::fstream::in | std::fstream::out | std::fstream::app);
        if (!file.is_open()) {
            throw std::runtime_error("Failed to open file");
        }
        std::cout << "File opened\n";
    }
    ~FileHandle() {
        if (file.is_open()) {
            file.close();
            std::cout << "File closed\n";
        }
    }
    void write(const std::string& data) {
        if (file.is_open()) {
            file << data << std::endl;
        }
    }
};

void useFile(const std::string& filename) {
    FileHandle fileHandle(filename);
    fileHandle.write("Hello, RAII!");
    // File is automatically closed when fileHandle goes out of scope
}

int main() {
    try {
        useFile("example.txt");
    } catch (const std::exception& e) {
        std::cerr << e.what() << std::endl;
    }
    return 0;
}

In this example, the FileHandle class encapsulates the logic for opening and closing a file. The file is automatically closed when the FileHandle object goes out of scope, ensuring proper resource management.

Example 3: Managing Mutex Locks:
Using RAII to manage mutex locks with std::lock_guard.

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

std::mutex mtx;

void safePrint(const std::string& message) {
    std::lock_guard<std::mutex> lock(mtx);
    std::cout << message << std::endl;
    // Mutex is automatically unlocked when lock goes out of scope
}

void threadFunction() {
    for (int i = 0; i < 5; ++i) {
        safePrint("Hello from thread");
    }
}

int main() {
    std::thread t1(threadFunction);
    std::thread t2(threadFunction);

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

    return 0;
}

In this example, std::lock_guard is used to manage the mutex lock. The mutex is automatically locked when lock is created and unlocked when lock goes out of scope, ensuring thread-safe access to the shared resource.

Summary:
RAII is a powerful idiom in C++ that ties resource management to object lifetimes, ensuring that resources are automatically acquired and released. By using RAII, programmers can write safer, more reliable, and more maintainable code, with reduced risk of resource leaks and enhanced exception safety. The examples demonstrate how RAII can be applied to manage dynamic memory, file handles, and mutex locks, showcasing its versatility and effectiveness in various scenarios.