RAII C++ — Double-Close Bug in Payment Gateway

#include <fstream>
#include <stdexcept>
#include <string>

namespace io::thecodeforge {

class FileGuard {
public:
    explicit FileGuard(const std::string& path)
        : file_(path, std::ios::in) {
        if (!file_.is_open()) {
            throw std::runtime_error("Failed to open: " + path);
        }
    }

    ~FileGuard() {
        if (file_.is_open()) {
            file_.close();
        }
    }

    // No copy — resource ownership can't be duplicated
    FileGuard(const FileGuard&) = delete;
    FileGuard& operator=(const FileGuard&) = delete;

    // Move transfers ownership
    FileGuard(FileGuard&& other) noexcept
        : file_(std::move(other.file_)) {}

    std::string read_line() {
        std::string line;
        if (!std::getline(file_, line)) {
            throw std::runtime_error("Read failed");
        }
        return line;
    }

private:
    std::ifstream file_;
};

} // namespace io::thecodeforge

// Usage — no manual close, even if read_line throws
void process_config(const std::string& path) {
    auto guard = io::thecodeforge::FileGuard(path);
    auto line = guard.read_line();
    // ... do work ...
    // ~FileGuard runs here
}

#include <iostream>
#include <stdexcept>

namespace io::thecodeforge {

class ScopedPrinter {
public:
    explicit ScopedPrinter(const char* msg) : msg_(msg) {
        std::cout << "Acquire: " << msg_ << "\n";
    }
    ~ScopedPrinter() {
        std::cout << "Release: " << msg_ << "\n";
    }
private:
    const char* msg_;
};

void might_throw(bool should) {
    ScopedPrinter p("lock");    // acquires
    ScopedPrinter q("file");   // acquires
    if (should) {
        throw std::runtime_error("something bad");
    }
    // p and q destroyed here (if no throw) or during unwind
}

} // namespace io::thecodeforge

int main() {
    try {
        io::thecodeforge::might_throw(true);
    } catch (...) {
        std::cout << "Caught exception\n";
    }
    // Output:
    // Acquire: lock
    // Acquire: file
    // Release: file
    // Release: lock
    // Caught exception
}

#include <memory>
#include <mutex>
#include <fstream>
#include <iostream>

namespace io::thecodeforge {

// Use unique_ptr for heap allocation
class Config {
public:
    void load() {
        std::lock_guard<std::mutex> guard(mutex_);  // lock automatically
        // ... parse config ...
        // destructor unlocks mutex_
    }
private:
    std::mutex mutex_;
};

// Factory returns unique_ptr — no ownership confusion
std::unique_ptr<Config> create_config(const std::string& path) {
    auto config = std::make_unique<Config>();
    // No raw new, no delete needed
    return config;
}

// Using an fstream in an RAII context
void process_line(const std::string& path) {
    std::ifstream file(path);  // opens in constructor
    if (!file) {
        throw std::runtime_error("cannot open");
    }
    std::string line;
    std::getline(file, line);
    // ~ifstream closes file automatically
}

} // namespace io::thecodeforge

#include <utility>
#include <cstring>

namespace io::thecodeforge {

class Buffer {
public:
    explicit Buffer(size_t size)
        : data_(new char[size]), size_(size) {}

    ~Buffer() {
        delete[] data_;
    }

    // Copy = deleted because we own raw memory
    Buffer(const Buffer&) = delete;
    Buffer& operator=(const Buffer&) = delete;

    // Move constructor: steal the pointer
    Buffer(Buffer&& other) noexcept
        : data_(other.data_), size_(other.size_) {
        other.data_ = nullptr;  // empty state
        other.size_ = 0;
    }

    // Move assignment: release current, steal from other
    Buffer& operator=(Buffer&& other) noexcept {
        if (this != &other) {
            delete[] data_;               // release our old resource
            data_ = other.data_;
            size_ = other.size_;
            other.data_ = nullptr;
            other.size_ = 0;
        }
        return *this;
    }

private:
    char* data_;
    size_t size_;
};

// Returning a local Buffer from a function works because of move
Buffer create_buffer(size_t sz) {
    Buffer b(sz);
    // ... fill ...
    return b;  // move, not copy (even in C++11)
}

} // namespace io::thecodeforge

#include <memory>
#include <iostream>

namespace io::thecodeforge {

// Bad: circular shared_ptr
struct Node {
    std::shared_ptr<Node> next;
    ~Node() { std::cout << "~Node\n"; }
};

void circular_demo() {
    auto a = std::make_shared<Node>();
    auto b = std::make_shared<Node>();
    a->next = b;
    b->next = a;  // circular — destructors never run!
}

// Fix: use weak_ptr for back references
struct Node2 {
    std::shared_ptr<Node2> next;
    std::weak_ptr<Node2> prev;  // weak, not shared
    ~Node2() { std::cout << "~Node2\n"; }
};

void no_circular_demo() {
    auto a = std::make_shared<Node2>();
    auto b = std::make_shared<Node2>();
    a->next = b;
    b->prev = a;  // weak, no cycle
    // both destroyed when original pointers go out of scope
}

// Destructor exception safety
class Risky {
public:
    ~Risky() noexcept(false) {
        // Simulate a failure
        throw std::runtime_error("destructor fail");
    }
};

void risk_demo() {
    try {
        Risky r1;
        Risky r2;  // both destructors will throw on unwind
    } catch (...) {
        // Only one exception escapes; second causes terminate
    }
}

} // namespace io::thecodeforge

#include <coroutine>
#include <memory>
#include <iostream>

namespace io::thecodeforge {

struct Resource {
    ~Resource() { std::cout << "~Resource\n"; }
};

struct Task {
    struct promise_type {
        std::unique_ptr<Resource> res = std::make_unique<Resource>();
        Task get_return_object() { return {std::coroutine_handle<promise_type>::from_promise(*this)}; }
        std::suspend_never initial_suspend() { return {}; }
        std::suspend_always final_suspend() noexcept { return {}; }
        void return_void() {}
        void unhandled_exception() { std::terminate(); }
    };
    std::coroutine_handle<promise_type> handle;
    ~Task() { if (handle) handle.destroy(); }
};

Task example() {
    // Resource is owned by promise_type, destructor runs when coroutine completes
    co_return;
}

} // namespace io::thecodeforge

int main() {
    auto t = io::thecodeforge::example();
    // t's destructor calls handle.destroy(), which destroys promise and thus Resource
}