std::uncaught_exception, std::uncaught_exceptions

bool uncaught_exception() throw();

bool uncaught_exception() noexcept;

int uncaught_exceptions() noexcept;

Il est parfois sûr de lever une exception même pendant que std::uncaught_exception() == true(jusqu'à C++17) std::uncaught_exceptions() > 0(depuis C++17). Par exemple, si le déroulement de la pile provoque la destruction d'un objet, le destructeur de cet objet pourrait exécuter du code qui lève une exception tant que cette exception est attrapée par un bloc catch avant de quitter le destructeur.

Valeur de retour

Notes

Un exemple où uncaught_exceptions à retour int est utilisé est la bibliothèque boost.log : l'expression BOOST_LOG(logger) << foo(); crée d'abord un objet de garde et enregistre le nombre d'exceptions non attrapées dans son constructeur. La sortie est effectuée par le destructeur de l'objet de garde sauf si foo() lève une exception (auquel cas le nombre d'exceptions non attrapées dans le destructeur est supérieur à celui observé par le constructeur).

std::experimental::scope_fail et std::experimental::scope_success dans LFTS v3 reposent sur la fonctionnalité de uncaught_exceptions, car leurs destructeurs doivent faire des choses différentes selon que l'appel a lieu pendant le déroulement de la pile.

Exemple

#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

Rapports de défauts

Les rapports de défauts suivants, modifiant le comportement, ont été appliqués rétroactivement aux normes C++ précédemment publiées.

Voir aussi

Liens externes