Exception Handling in C++ — try, catch, throw and Real-World Patterns

#include <iostream>
#include <stdexcept>  // gives us std::runtime_error and friends
#include <string>

// Simulates reading a user's age from some input source
// In a real app this might parse a config file or a network packet
int parseAge(const std::string& rawInput) {
    // stoi throws std::invalid_argument if the string isn't a number
    // and std::out_of_range if the number is too large for an int
    int age = std::stoi(rawInput);  // this is the risky operation

    // Business-logic validation — we throw our own error with a clear message
    if (age < 0 || age > 150) {
        throw std::out_of_range(
            "Age must be between 0 and 150, got: " + rawInput
        );
    }

    return age;
}

int main() {
    // --- Test Case 1: valid input ---
    try {
        int validAge = parseAge("28");
        std::cout << "Parsed age successfully: " << validAge << "\n";
    } catch (const std::exception& error) {
        // We won't reach here for valid input
        std::cerr << "Error: " << error.what() << "\n";
    }

    // --- Test Case 2: non-numeric input ---
    try {
        int badAge = parseAge("banana");  // stoi will throw invalid_argument
        std::cout << "This line never prints: " << badAge << "\n";
    } catch (const std::invalid_argument& error) {
        // Catches specifically the 'not a number' case
        std::cerr << "[invalid_argument] " << error.what() << "\n";
    } catch (const std::out_of_range& error) {
        // Catches the 'number out of valid range' case
        std::cerr << "[out_of_range] " << error.what() << "\n";
    }

    // --- Test Case 3: logically invalid age ---
    try {
        int impossibleAge = parseAge("300");  // our business-rule throw
        std::cout << "This line never prints: " << impossibleAge << "\n";
    } catch (const std::out_of_range& error) {
        std::cerr << "[out_of_range] " << error.what() << "\n";
    }

    std::cout << "Program continues normally after all catch blocks.\n";
    return 0;
}

#include <iostream>
#include <memory>     // for std::unique_ptr
#include <stdexcept>
#include <string>

// A simple RAII wrapper that logs when it's created and destroyed
// This models any real resource: a file, a DB connection, a mutex lock
class DatabaseConnection {
public:
    explicit DatabaseConnection(const std::string& host) : host_(host) {
        std::cout << "  [DB] Connected to " << host_ << "\n";
    }

    void executeQuery(const std::string& sql) {
        std::cout << "  [DB] Running: " << sql << "\n";
        // Simulate a query that fails on bad SQL
        if (sql.find("DROP") != std::string::npos) {
            throw std::runtime_error("Refusing dangerous query: " + sql);
        }
    }

    // Destructor runs automatically — even during stack unwinding!
    ~DatabaseConnection() {
        std::cout << "  [DB] Connection to " << host_ << " closed cleanly.\n";
    }

private:
    std::string host_;
};

void runReportJob() {
    // unique_ptr ensures DatabaseConnection is destroyed when this
    // function exits — whether normally OR via exception
    auto db = std::make_unique<DatabaseConnection>("prod-db-01");

    db->executeQuery("SELECT * FROM orders WHERE date = '2024-01-01'");

    // This line throws — but the destructor of `db` WILL still run
    db->executeQuery("DROP TABLE orders");  // <-- exception thrown here

    // This line is never reached
    db->executeQuery("COMMIT");
}

int main() {
    std::cout << "Starting report job...\n";

    try {
        runReportJob();
    } catch (const std::runtime_error& error) {
        // We land here after the stack has been fully unwound
        // Notice the DB destructor already ran before we got here
        std::cerr << "\nJob failed: " << error.what() << "\n";
    }

    std::cout << "\nSystem remains stable. No resource leak.\n";
    return 0;
}

#include <iostream>
#include <stdexcept>
#include <string>

// ---- Custom Exception Hierarchy ----
// Base class for all errors in our payment module.
// Inheriting from std::runtime_error gives us what() for free.
class PaymentException : public std::runtime_error {
public:
    explicit PaymentException(const std::string& message)
        : std::runtime_error("[Payment] " + message) {}
};

// Specific error: the card was declined by the bank
class CardDeclinedException : public PaymentException {
public:
    CardDeclinedException(const std::string& lastFourDigits, const std::string& reason)
        : PaymentException("Card ending in " + lastFourDigits + " declined: " + reason),
          lastFourDigits_(lastFourDigits) {}

    // Extra structured data only this exception type carries
    const std::string& lastFourDigits() const { return lastFourDigits_; }

private:
    std::string lastFourDigits_;
};

// Specific error: account doesn't have enough funds
class InsufficientFundsException : public PaymentException {
public:
    InsufficientFundsException(double available, double required)
        : PaymentException(
            "Need $" + std::to_string(required) +
            " but only $" + std::to_string(available) + " available"),
          shortfall_(required - available) {}

    double shortfall() const { return shortfall_; }

private:
    double shortfall_;
};

// ---- Simulated Payment Processor ----
void processPayment(const std::string& cardNumber, double amount, double accountBalance) {
    // Simulate a declined card
    if (cardNumber == "4111-DECLINED") {
        throw CardDeclinedException("1234", "suspected fraud");
    }

    // Simulate insufficient funds
    if (accountBalance < amount) {
        throw InsufficientFundsException(accountBalance, amount);
    }

    std::cout << "Payment of $" << amount << " processed successfully.\n";
}

int main() {
    // --- Scenario 1: Card declined ---
    std::cout << "--- Scenario 1: Declined Card ---\n";
    try {
        processPayment("4111-DECLINED", 99.99, 500.00);
    } catch (const CardDeclinedException& error) {
        // We get structured data, not just a string
        std::cerr << error.what() << "\n";
        std::cerr << "Suggest user update card ending in: "
                  << error.lastFourDigits() << "\n";
    } catch (const PaymentException& error) {
        // Generic payment handler — catches anything else in the hierarchy
        std::cerr << "Payment failed: " << error.what() << "\n";
    }

    // --- Scenario 2: Insufficient funds ---
    std::cout << "\n--- Scenario 2: Insufficient Funds ---\n";
    try {
        processPayment("4111-OK", 250.00, 100.00);
    } catch (const InsufficientFundsException& error) {
        std::cerr << error.what() << "\n";
        std::cerr << "Shortfall: $" << error.shortfall() << ". Suggest top-up.\n";
    } catch (const PaymentException& error) {
        std::cerr << "Payment failed: " << error.what() << "\n";
    }

    // --- Scenario 3: Success ---
    std::cout << "\n--- Scenario 3: Successful Payment ---\n";
    try {
        processPayment("4111-OK", 49.99, 500.00);
    } catch (const PaymentException& error) {
        std::cerr << "Payment failed: " << error.what() << "\n";
    }

    return 0;
}

#include <iostream>
#include <vector>
#include <string>
#include <stdexcept>

// Demonstrates the STRONG exception safety guarantee using copy-then-swap.
// The goal: either the update fully succeeds, or the object is UNCHANGED.
class UserProfile {
public:
    UserProfile(std::string name, std::string email)
        : name_(std::move(name)), email_(std::move(email)) {}

    // UNSAFE version — partial updates leave object in broken state
    void updateUnsafe(const std::string& newName, const std::string& newEmail) {
        name_ = newName;    // succeeds
        email_ = newEmail;  // if THIS threw, name_ is already changed — broken state!
        validateEmail();    // imagine this throws for invalid email format
    }

    // SAFE version — uses copy-then-swap for strong guarantee
    void updateSafe(const std::string& newName, const std::string& newEmail) {
        // Step 1: Work on a COPY. If anything throws here, 'this' is untouched.
        UserProfile temp(newName, newEmail);
        temp.validateEmail();  // validate on the copy — throws if invalid

        // Step 2: Only if everything succeeded, swap with noexcept swap.
        // swap itself must not throw — otherwise the guarantee breaks.
        using std::swap;
        swap(name_, temp.name_);    // noexcept swap on strings
        swap(email_, temp.email_);  // noexcept swap on strings

        // If we got here, the update is fully committed.
    }

    void print() const {
        std::cout << "  Name: " << name_ << ", Email: " << email_ << "\n";
    }

private:
    std::string name_;
    std::string email_;

    void validateEmail() const {
        // Simplified validation — real code would be more thorough
        if (email_.find('@') == std::string::npos) {
            throw std::invalid_argument(
                "Invalid email format: '" + email_ + "' — missing '@'"
            );
        }
    }
};

int main() {
    UserProfile profile("Alice", "alice@example.com");

    std::cout << "Before update:\n";
    profile.print();

    // --- Try the SAFE update with invalid email ---
    std::cout << "\nAttempting safe update with bad email...\n";
    try {
        profile.updateSafe("Alice Smith", "not-a-valid-email");
    } catch (const std::invalid_argument& error) {
        std::cerr << "Update rejected: " << error.what() << "\n";
    }

    // The profile is COMPLETELY UNCHANGED — strong guarantee held
    std::cout << "After failed safe update (should be unchanged):\n";
    profile.print();

    // --- Now do a valid update ---
    std::cout << "\nAttempting safe update with good email...\n";
    try {
        profile.updateSafe("Alice Smith", "alice.smith@example.com");
    } catch (const std::invalid_argument& error) {
        std::cerr << "Update rejected: " << error.what() << "\n";
    }

    std::cout << "After successful safe update:\n";
    profile.print();

    return 0;
}