¿Con qué se guardan las excepciones en C++?

Con objetos. Al lanzar una excepción con throw, se crea un objeto temporal que luego se pasa al mecanismo de manejo de excepciones. El tipo de este objeto determina qué manejador catch será seleccionado.

Aquí hay un ejemplo que demuestra cómo guardar excepciones en forma de objetos:

#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) {
        // Lanzamos una excepción - objeto de la clase MyException
        throw MyException(-1);
    }
    if (val == 0) {
        // Lanzamos una excepción estándar - objeto de la clase std::runtime_error
        throw std::runtime_error("El valor no puede ser cero.");
    }
    std::cout << "El valor es positivo: " << val << std::endl;
}

int main() {
    try {
        test_func(-5);
    } catch (const MyException& e) {
        // Capturamos la excepción por tipo de objeto MyException
        std::cerr << "Capturada MyException con código: " << e.get_code() << std::endl;
    } catch (const std::runtime_error& e) {
        // Capturamos la excepción por tipo de objeto std::runtime_error
        std::cerr << "Capturada std::runtime_error: " << e.what() << std::endl;
    } catch (...) {
        // Capturamos cualquier otra excepción
        std::cerr << "Excepción desconocida capturada." << std::endl;
    }

    try {
        test_func(0);
    } catch (const std::exception& e) {
        // Se puede capturar la clase base para excepciones estándar
        std::cerr << "Excepción estándar capturada: " << e.what() << std::endl;
    }

    return 0;
}