C++ for C Developers | Lesson 10: Exception Handling: A Robust Approach to Errors

#include <iostream>
#include <string>
#include <vector>
#include <stdexcept> // Required for standard exception classes like std::out_of_range

// Function that might throw an exception
double get_element_at(const std::vector<double>& data, size_t index) {
    // Check for a condition that prevents normal execution
    if (index >= data.size()) {
        // Throw an exception object indicating the error
        throw std::out_of_range(
            "Index " + std::to_string(index) +
            " is out of range for vector of size " + std::to_string(data.size())
        );
        // Execution of this function stops HERE if exception is thrown
    }
    // This part only runs if the condition above was false (no throw)
    return data[index]; // Use [] because we already checked bounds
}

int main() {
    std::vector<double> values = {10.5, 20.0, 30.2};
    size_t valid_index = 1;
    size_t invalid_index = 5;

    std::cout << "Attempting to access elements..." << std::endl;

    try {
        // --- Code that might throw ---
        std::cout << "Trying valid index " << valid_index << std::endl;
        double val1 = get_element_at(values, valid_index);
        std::cout << "  Value at index " << valid_index << ": " << val1 << std::endl;

        std::cout << "Trying invalid index " << invalid_index << std::endl;
        double val2 = get_element_at(values, invalid_index); // This call will throw!
        // This line below WILL NOT be reached if the line above throws
        std::cout << "  Value at index " << invalid_index << ": " << val2 << std::endl;

    } catch (const std::out_of_range& oor) { // Catch specific exception type by const reference
        // --- Error Handling Code ---
        // This block executes because get_element_at threw std::out_of_range
        std::cerr << "!! Caught an out_of_range exception !!" << std::endl;
        std::cerr << "   Error details: " << oor.what() << std::endl; // what() gives the error message
        // Handle the error (e.g., log, return error code from main, use default value)

    } catch (const std::exception& e) {
        // --- Catching other standard exceptions ---
        // This catches any other exception derived from std::exception
        // that wasn't caught by the more specific handler above.
        std::cerr << "!! Caught some other standard exception: " << e.what() << std::endl;

    } catch (...) {
         // --- Catch-all (Use Sparingly) ---
         // Catches ANY exception type, including non-standard ones.
         // Usually used for last-resort cleanup or logging.
         std::cerr << "!! Caught an unknown exception type !!" << std::endl;
    }

    std::cout << "Program continues after try-catch block." << std::endl;

    // Note: Execution jumps from the 'throw' to the matching 'catch' block.
    // Code after the throw in the try block is skipped.
    // Code after the try-catch block executes normally.

    return 0; // Or return non-zero if an error was caught
}

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

// Simple RAII class (e.g., manages a resource like a log entry)
class Logger {
private:
    std::string func_name;
public:
    Logger(std::string name) : func_name(std::move(name)) {
        std::cout << "[Entering " << func_name << "]" << std::endl;
    }
    ~Logger() { // Destructor is the key!
        std::cout << "[Exiting " << func_name << "] <--- Destructor Called!" << std::endl;
    }
    // Prevent copying
    Logger(const Logger&) = delete;
    Logger& operator=(const Logger&) = delete;
};

void functionB() {
    Logger log("functionB"); // RAII object created on stack
    std::cout << "  In functionB, about to throw..." << std::endl;
    throw std::runtime_error("Problem occurred in functionB");
    // Destructor ~Logger() for 'log' WILL be called during stack unwinding.
}

void functionA() {
    Logger log("functionA"); // RAII object created on stack
    std::cout << "  In functionA, calling functionB..." << std::endl;
    functionB(); // This call leads to an exception
    std::cout << "  This line in functionA is never reached." << std::endl;
     // Destructor ~Logger() for 'log' WILL be called during stack unwinding.
}

int main() {
    Logger log("main");
    try {
        functionA();
    } catch (const std::runtime_error& e) {
        std::cerr << "** Caught Exception in main: " << e.what() << " **" << std::endl;
    }
    // Destructor ~Logger() for 'log' called when main exits.
    return 0;
}

[Entering main]
[Entering functionA]
  In functionA, calling functionB...
[Entering functionB]
  In functionB, about to throw...
[Exiting functionB] <--- Destructor Called!
[Exiting functionA] <--- Destructor Called!
** Caught Exception in main: Problem occurred in functionB **
[Exiting main] <--- Destructor Called!

void process_data() noexcept { /* ... safe code ... */ }

class MyData {
    // ...
public:
    ~MyData() noexcept { /* Destructors should not throw */ }
};