Namespaces
Variants

    std::uncaught_exception, std::uncaught_exceptions

    Von de.cppreference.net
     
    C++
     
    Diagnosebibliothek
     
    Definiert in Header <exception> 
    bool uncaught_exception() throw();
    		(1) (bis C++11) 
    bool uncaught_exception() noexcept;
    		(seit C++11)
    (veraltet in C++17)
    (entfernt in C++20)    		 
    int uncaught_exceptions() noexcept;
    		(2) (seit C++17)
    (constexpr seit C++26)
    1) Erkennt, ob der aktuelle Thread ein lebendiges Ausnahmeobjekt besitzt, das heißt, eine Ausnahme wurde geworfen oder erneut geworfen und hat noch keine passende catch-Klausel, std::terminate oder std::unexpected erreicht. Mit anderen Worten: std::uncaught_exception erkennt, ob Stack-Entladung derzeit im Gange ist.
    2) Erkennt, wie viele Ausnahmen im aktuellen Thread geworfen oder erneut geworfen wurden und noch nicht ihre passenden catch-Klauseln erreicht haben.

    Manchmal ist es sicher, eine Ausnahme zu werfen, selbst während std::uncaught_exception() == true(bis C++17) std::uncaught_exceptions() > 0(seit C++17). Beispielsweise, wenn Stack-Entladung dazu führt, dass ein Objekt zerstört wird, könnte der Destruktor dieses Objekts Code ausführen, der eine Ausnahme wirft, solange die Ausnahme von einem catch-Block abgefangen wird, bevor sie den Destruktor verlässt.

    Rückgabewert

    1) true wenn Stack Unwinding derzeit in diesem Thread stattfindet, false andernfalls.
    2) Die Anzahl der nicht abgefangenen Ausnahmeobjekte im aktuellen Thread.

    Hinweise

    Ein Beispiel, bei dem die int-returning uncaught_exceptions verwendet wird, ist die boost.log Bibliothek: Der Ausdruck BOOST_LOG ( logger ) << foo ( ) ; erstellt zunächst ein Guard-Objekt und zeichnet die Anzahl der uncaught exceptions in seinem Konstruktor auf. Die Ausgabe wird durch den Destruktor des Guard-Objekts durchgeführt, es sei denn foo ( ) wirft eine Exception (in diesem Fall ist die Anzahl der uncaught exceptions im Destruktor größer als die, die der Konstruktor beobachtet hat).

    std::experimental::scope_fail und std::experimental::scope_success in LFTS v3 basieren auf der Funktionalität von uncaught_exceptions , da ihre Destruktoren unterschiedliche Aktionen ausführen müssen, die davon abhängen, ob sie während des Stack-Unwinding aufgerufen werden.

    Feature-Test Makro Wert Std Feature
    __cpp_lib_uncaught_exceptions 201411L (C++17) std::uncaught_exceptions
    __cpp_lib_constexpr_exceptions 202411L (C++26) constexpr für Ausnahmetypen

    Beispiel

    Diesen Code ausführen 
    #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';
    }
}

    Mögliche Ausgabe: 

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

    Fehlerberichte

    Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

    DR Angewendet auf Verhalten wie veröffentlicht Korrigiertes Verhalten
    LWG 70 C++98 die Exception-Spezifikation von uncaught_exception() fehlte spezifiziert als throw()

    Siehe auch

    		Funktion, die aufgerufen wird, wenn die Ausnahmebehandlung fehlschlägt
    (Funktion)
    (C++11)
    		Shared-Pointer-Typ zur Behandlung von Ausnahmeobjekten
    (Typdefinition)
    (C++11)
    		erfasst die aktuelle Ausnahme in einem std::exception_ptr
    (Funktion)

    Externe Links

    1. GOTW-Ausgabe 47: Unbehandelte Ausnahmen
    2. Begründung für std::uncaught_exceptions (N4125)