Namespaces
Variants

std:: set_terminate

From cppreference.net
C++
Diagnostics library
Definiert im Header <exception>
(bis C++11)
(seit C++11)

Macht f zur neuen globalen Terminate-Handler-Funktion und gibt den zuvor installierten std::terminate_handler zurück. f muss die Programmausführung beenden, ohne zum Aufrufer zurückzukehren, andernfalls ist das Verhalten undefiniert.

Diese Funktion ist Thread-sicher. Jeder Aufruf von std::set_terminate synchronisiert mit (siehe std::memory_order ) nachfolgenden Aufrufen von std::set_terminate und std::get_terminate .

(seit C++11)

Inhaltsverzeichnis

Parameter

f - Zeiger auf eine Funktion vom Typ std::terminate_handler oder ein Nullzeiger

Rückgabewert

Der zuvor installierte Terminierungs-Handler oder ein Nullzeigerwert, falls keiner installiert war.

Beispiel

Diesen Code ausführen 
#include <cstdlib>
#include <exception>
#include <iostream>
int main()
{
    std::set_terminate([]()
    {
        std::cout << "Unhandled exception\n" << std::flush;
        std::abort();
    });
    throw 1;
}

Mögliche Ausgabe: 

Unhandled exception
bash: line 7:  7743 Aborted                 (core dumped) ./a.out

Der Terminate-Handler funktioniert auch für gestartete Threads, daher kann er als Alternative zum Umschließen der Thread-Funktion mit einem try / catch -Block verwendet werden. Im folgenden Beispiel wird, da die Ausnahme nicht behandelt wird, std::terminate aufgerufen.

Diesen Code ausführen 
#include <iostream>
#include <thread>
void run()
{
    throw std::runtime_error("Thread failure");
}
int main()
{
    try
    {
        std::thread t{run};
        t.join();
        return EXIT_SUCCESS;
    }
    catch (const std::exception& ex)
    {
        std::cerr << "Exception: " << ex.what() << '\n';
    }
    catch (...)
    {
        std::cerr << "Unknown exception caught\n";
    }
    return EXIT_FAILURE;
}

Mögliche Ausgabe: 

terminate called after throwing an instance of 'std::runtime_error'
  what():  Thread failure
Aborted (core dumped)

Mit der Einführung des Terminate-Handlers kann die Ausnahme, die aus dem Nicht-Hauptthread geworfen wird, analysiert werden, und ein sauberer Exit kann durchgeführt werden.

Diesen Code ausführen 
#include <iostream>
#include <thread>
class foo
{
public:
    foo() { std::cerr << "foo::foo()\n"; }
    ~foo() { std::cerr << "foo::~foo()\n"; }
};
// Statisches Objekt, Destruktor beim Beenden erwartet
foo f;
void run()
{
    throw std::runtime_error("Thread failure");
}
int main()
{
    std::set_terminate([]()
    {
        try
        {
            std::exception_ptr eptr{std::current_exception()};
            if (eptr)
            {
                std::rethrow_exception(eptr);
            }
            else
            {
                std::cerr << "Exiting without exception\n";
            }
        }
        catch (const std::exception& ex)
        {
            std::cerr << "Exception: " << ex.what() << '\n';
        }
        catch (...)
        {
            std::cerr << "Unknown exception caught\n";
        }
        std::exit(EXIT_FAILURE);
    });
    std::thread t{run};
    t.join();
}

Ausgabe: 

foo::foo()
Exception: Thread failure
foo::~foo()

Siehe auch

Funktion, die aufgerufen wird, wenn die Ausnahmebehandlung fehlschlägt
(Funktion)
(C++11)
ermittelt den aktuellen terminate_handler
(Funktion)
der Typ der Funktion, die von std::terminate aufgerufen wird
(Typdefinition)