Hoe worden uitzonderingen opgeslagen in C++?

Met objecten. Wanneer een uitzondering wordt gegooid met throw, wordt er een tijdelijk object gemaakt dat vervolgens wordt doorgegeven aan het mechanisme voor het afhandelen van uitzonderingen. Het type van dit object bepaalt welke catch-handler wordt geselecteerd.

Hier is een voorbeeld dat laat zien hoe uitzonderingen worden opgeslagen als objecten:

#include <iostream>
#include <stdexcept>

class MyException {
    int error_code;
public:
    MyException(int code) : error_code(code) {}
    int get_code() const { return error_code; }
};

void test_func(int val) {
    if (val < 0) {
        // Gooit een uitzondering - object van de klasse MyException
        throw MyException(-1);
    }
    if (val == 0) {
        // Gooit een standaard uitzondering - object van de klasse std::runtime_error
        throw std::runtime_error("Waarde kan niet nul zijn.");
    }
    std::cout << "Waarde is positief: " << val << std::endl;
}

int main() {
    try {
        test_func(-5);
    } catch (const MyException& e) {
        // Vangt de uitzondering op type van het MyException-object
        std::cerr << "MyException gevangen met code: " << e.get_code() << std::endl;
    } catch (const std::runtime_error& e) {
        // Vangt de uitzondering op type van het std::runtime_error-object
        std::cerr << "std::runtime_error gevangen: " << e.what() << std::endl;
    } catch (...) {
        // Vangt elke andere uitzondering
        std::cerr << "Onbekende uitzondering gevangen." << std::endl;
    }

    try {
        test_func(0);
    } catch (const std::exception& e) {
        // Kan de basisklasse voor standaard uitzonderingen vangen
        std::cerr << "Standaard uitzondering gevangen: " << e.what() << std::endl;
    }

    return 0;
}