C++ RAII: Resource Acquisition Is Initialization — The Foundation of Safe C++

// Failure mode 1: Early return that skips cleanup
void process_file(const char* path) {
    FILE* f = fopen(path, "r");
    if (!f) return;
    
    char* buffer = malloc(4096);
    if (!buffer) {
        fclose(f);   // Remembered here...
        return;
    }
    
    if (parse_header(f) < 0) {
        free(buffer);
        fclose(f);   // Remembered here...
        return;
    }
    
    // ... 50 more lines of logic, each needing the same cleanup ...
    
    free(buffer);
    fclose(f); // Finally! But any exception between here and fopen leaks both
}

// Failure mode 2: Exception thrown mid-function
// Failure mode 3: Code reviewer adds an early-return and forgets cleanup
// All three: RAII prevents automatically

class FileHandle {
    FILE* file_;
    
public:
    // Constructor: Acquire the resource
    explicit FileHandle(const char* path, const char* mode)
        : file_(std::fopen(path, mode)) {
        if (!file_) {
            throw std::system_error(errno, std::system_category(),
                                    std::string("Cannot open: ") + path);
        }
    }
    
    // Destructor: Release the resource — NO MATTER WHAT
    ~FileHandle() noexcept {
        if (file_) std::fclose(file_);
    }
    
    // Non-copyable (a file handle has one owner)
    FileHandle(const FileHandle&)            = delete;
    FileHandle& operator=(const FileHandle&) = delete;
    
    // Movable (transfer ownership)
    FileHandle(FileHandle&& other) noexcept
        : file_(std::exchange(other.file_, nullptr)) {}
    
    FILE* get() const noexcept { return file_; }
    
    // Bool conversion for validity check
    explicit operator bool() const noexcept { return file_ != nullptr; }
};

// Now this function is always safe:
void process_file_raii(const char* path) {
    FileHandle f("data.txt", "r");  // Opened in constructor
    
    if (some_error()) return;       // f.~FileHandle() called here → closed ✅
    
    parse_content(f.get());
    
} // f.~FileHandle() called here too → closed ✅
// No explicit fclose needed ANYWHERE — impossible to leak

#include <mutex>

std::mutex mtx;
int shared_counter = 0;

// lock_guard: Simple, non-movable RAII lock (prefer this)
void increment_safe() {
    std::lock_guard<std::mutex> lock(mtx); // Locks on construction
    shared_counter++;
    // lock.~lock_guard() → unlocks unconditionally when function exits
    // Even if an exception is thrown!
}

// C++17 CTAD (Class Template Argument Deduction):
void increment_ctad() {
    std::lock_guard lock(mtx); // No <std::mutex> needed — deduced
    shared_counter++;
}

// unique_lock: Flexible RAII lock — can be unlocked manually, moved
void flexible_lock() {
    std::unique_lock<std::mutex> lock(mtx);  // Locked
    
    // Do protected work
    shared_counter++;
    
    lock.unlock(); // Manually unlock when done — reduce lock hold time
    
    do_slow_io();  // IO outside the lock — better concurrency
    
    lock.lock();   // Lock again if needed
    finalize();
}  // lock destructor unlocks if still locked

// Try-lock pattern:
void try_access() {
    if (std::unique_lock lock(mtx, std::try_to_lock); lock.owns_lock()) {
        // Got the lock! (C++17 if-with-initializer + try_to_lock)
        process_critical_data();
    } else {
        // Couldn't acquire — do something else
        use_cached_result();
    }
}

// Defer lock pattern:
void deferred_lock() {
    std::unique_lock lock(mtx, std::defer_lock); // Don't lock yet
    // Do non-critical setup
    prepare_data();
    
    lock.lock(); // Now lock when needed
    write_shared();
}

#include <sys/socket.h>
#include <unistd.h>

// Generic POSIX file descriptor RAII wrapper
class FileDescriptor {
    int fd_;
    
public:
    explicit FileDescriptor(int fd) : fd_(fd) {
        if (fd < 0) throw std::system_error(errno, std::system_category());
    }
    
    ~FileDescriptor() noexcept {
        if (fd_ >= 0) ::close(fd_); // POSIX close() for any fd type
    }
    
    // Non-copyable
    FileDescriptor(const FileDescriptor&) = delete;
    FileDescriptor& operator=(const FileDescriptor&) = delete;
    
    // Movable
    FileDescriptor(FileDescriptor&& o) noexcept
        : fd_(std::exchange(o.fd_, -1)) {}
    
    int get() const noexcept { return fd_; }
    int release() noexcept { return std::exchange(fd_, -1); } // Relinquish ownership
};

// Works for ANY type of POSIX file descriptor:
FileDescriptor open_file("/etc/hosts", O_RDONLY);  // Regular file
FileDescriptor sock(socket(AF_INET, SOCK_STREAM, 0)); // Network socket
FileDescriptor pipe_fd(create_pipe());               // Pipe
// All correctly closed when they go out of scope

#include <scope>  // C++23

void process_with_legacy_c_api() {
    LibHandle* h = lib_open("resource");
    if (!h) throw std::runtime_error("Failed to open");
    
    // Guaranteed cleanup — even on exception, even on early return
    std::scope_exit cleanup([h]() noexcept {
        lib_close(h);
    });
    
    if (lib_initialize(h) != LIB_OK) return; // cleanup runs → lib_close(h) called ✅
    
    process(h);
    
} // cleanup runs → lib_close(h) called ✅

// scope_success: runs only if scope exits normally (no exception)
// scope_fail: runs only if scope exits via exception

template<typename F>
struct ScopeExit {
    F cleanup;
    explicit ScopeExit(F f) : cleanup(std::move(f)) {}
    ~ScopeExit() { cleanup(); }
};
// Usage: auto guard = ScopeExit{[&]{ cleanup(); }};

// Strong exception safety — copy-and-swap idiom:
class Config {
    std::vector<Setting> settings_;
    
public:
    // Strong guarantee: either all settings updated or none
    void update(std::vector<Setting> new_settings) {
        Config temp;
        temp.settings_ = std::move(new_settings); // May throw — temp is temporary
        
        // Copy-and-swap: only AFTER successful construction, swap
        std::swap(settings_, temp.settings_); // noexcept — safe
    } // temp.settings_ (old data) destroyed here
};