std:: current_exception

Wenn während der Ausnahmebehandlung aufgerufen (typischerweise in einem catch -Block), erfasst dies das aktuelle Ausnahmeobjekt und erstellt einen std::exception_ptr , der entweder eine Kopie oder eine Referenz auf dieses Ausnahmeobjekt enthält (abhängig von der Implementierung). Das referenzierte Objekt bleibt mindestens so lange gültig, wie ein exception_ptr -Objekt existiert, das darauf verweist.

Falls die Implementierung dieser Funktion einen Aufruf von new erfordert und dieser Aufruf fehlschlägt, enthält der zurückgegebene Zeiger eine Referenz auf eine Instanz von std::bad_alloc .

Falls die Implementierung dieser Funktion das Kopieren des gefangenen Ausnahmeobjekts erfordert und dessen Kopierkonstruktor eine Ausnahme wirft, enthält der zurückgegebene Zeiger eine Referenz auf die geworfene Ausnahme. Wenn der Kopierkonstruktor des geworfenen Ausnahmeobjekts ebenfalls eine Ausnahme wirft, kann der zurückgegebene Zeiger eine Referenz auf eine Instanz von std::bad_exception enthalten, um die Endlosschleife zu unterbrechen.

Wenn die Funktion aufgerufen wird, während keine Ausnahme behandelt wird, wird ein leerer std::exception_ptr zurückgegeben.

Diese Funktion kann in einem std::terminate_handler aufgerufen werden, um die Exception abzurufen, die den Aufruf von std::terminate ausgelöst hat.

Rückgabewert

Eine Instanz von std::exception_ptr , die eine Referenz auf das Ausnahmeobjekt oder eine Kopie des Ausnahmeobjekts enthält, oder eine Instanz von std::bad_alloc oder eine Instanz von std::bad_exception .

Hinweise

Auf Implementierungen, die dem Itanium C++ ABI folgen (GCC, Clang, etc.), werden Ausnahmen beim Werfen auf dem Heap allokiert (außer für std::bad_alloc in einigen Fällen), und diese Funktion erstellt einfach den Smart Pointer, der auf das zuvor allokierte Objekt verweist. Auf MSVC werden Ausnahmen beim Werfen auf dem Stack allokiert, und diese Funktion führt die Heap-Allokation durch und kopiert das Ausnahmeobjekt.

Unter Windows in verwalteten CLR-Umgebungen [1] speichert die Implementierung ein std::bad_exception , wenn die aktuelle Exception eine verwaltete Exception ist ( [2] ). Beachten Sie, dass catch ( ... ) auch verwaltete Exceptions abfängt:

#include <exception>
int main()
{
    try
    {
        throw gcnew System::Exception("Managed exception");
    }
    catch (...)
    {
        std::exception_ptr ex = std::current_exception();
        try
        {
            std::rethrow_exception(ex);
        }
        catch (std::bad_exception const &)
        {
            // Dies wird ausgegeben.
            std::cout << "Bad exception" << std::endl;
        }
    }
}

Beispiel

#include <exception>
#include <iostream>
#include <stdexcept>
#include <string>
void handle_eptr(std::exception_ptr eptr) // passing by value is OK
{
    try
    {
        if (eptr)
            std::rethrow_exception(eptr);
    }
    catch(const std::exception& e)
    {
        std::cout << "Caught exception: '" << e.what() << "'\n";
    }
}
int main()
{
    std::exception_ptr eptr;
    try
    {
        [[maybe_unused]]
        char ch = std::string().at(1); // this generates a std::out_of_range
    }
    catch(...)
    {
        eptr = std::current_exception(); // capture
    }
    handle_eptr(eptr);
} // destructor for std::out_of_range called here, when the eptr is destructed

Caught exception: 'basic_string::at: __n (which is 1) >= this->size() (which is 0)'

Siehe auch