std::uncaught_exception, std::uncaught_exceptions

bool uncaught_exception() throw();

bool uncaught_exception() noexcept;

int uncaught_exceptions() noexcept;

A veces es seguro lanzar una excepción incluso mientras std::uncaught_exception() == true(hasta C++17) std::uncaught_exceptions() > 0(desde C++17). Por ejemplo, si el desenrollado de la pila provoca la destrucción de un objeto, el destructor de ese objeto podría ejecutar código que lance una excepción siempre que la excepción sea capturada por algún bloque catch antes de escapar del destructor.

Valor de retorno

Notas

Un ejemplo donde se utiliza uncaught_exceptions que retorna int es la biblioteca boost.log: la expresión BOOST_LOG(logger) << foo(); primero crea un objeto guardián y registra el número de excepciones no capturadas en su constructor. La salida se realiza por el destructor del objeto guardián a menos que foo() lance una excepción (en cuyo caso el número de excepciones no capturadas en el destructor es mayor que el observado por el constructor).

std::experimental::scope_fail y std::experimental::scope_success en LFTS v3 dependen de la funcionalidad de uncaught_exceptions, porque sus destructores necesitan hacer cosas diferentes que dependen de si se llama durante el desenrollado de la pila.

Ejemplo

#include <exception>
#include <iostream>
#include <stdexcept>

struct Foo
{
    char id{'?'};
    int count = std::uncaught_exceptions();

    ~Foo()
    {
        count == std::uncaught_exceptions()
            ? std::cout << id << ".~Foo() called normally\n"
            : std::cout << id << ".~Foo() called during stack unwinding\n";
    }
};

int main()
{
    Foo f{'f'};

    try
    {
        Foo g{'g'};
        std::cout << "Exception thrown\n";
        throw std::runtime_error("test exception");
    }
    catch (const std::exception& e)
    {
        std::cout << "Exception caught: " << e.what() << '\n';
    }
}

Exception thrown
g.~Foo() called during stack unwinding
Exception caught: test exception
f.~Foo() called normally

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares C++ previamente publicados.

Véase también

Enlaces externos