Namespaces
Variants

std:: set_terminate

From cppreference.net
C++
Diagnostics library
Definido en el encabezado <exception>
(hasta C++11)
(desde C++11)

Hace que f sea la nueva función global de manejo de terminación y devuelve el std::terminate_handler previamente instalado. f debe terminar la ejecución del programa sin retornar a su llamador, de lo contrario el comportamiento es indefinido.

Esta función es segura para hilos. Cada llamada a std::set_terminate sincroniza-con (ver std::memory_order ) las llamadas posteriores a std::set_terminate y std::get_terminate .

(desde C++11)

Contenidos

Parámetros

f - puntero a función de tipo std::terminate_handler , o puntero nulo

Valor de retorno

El manejador de terminación previamente instalado, o un valor de puntero nulo si no se había instalado ninguno.

Ejemplo

Ejecutar este código 
#include <cstdlib>
#include <exception>
#include <iostream>
int main()
{
    std::set_terminate([]()
    {
        std::cout << "Unhandled exception\n" << std::flush;
        std::abort();
    });
    throw 1;
}

Salida posible: 

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

El manejador de terminación también funcionará para hilos lanzados, por lo que puede utilizarse como alternativa a envolver la función del hilo con un bloque try / catch . En el siguiente ejemplo, dado que la excepción no es manejada, std::terminate será llamado.

Ejecutar este código 
#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;
}

Salida posible: 

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

Con la introducción del manejador de terminación, la excepción lanzada desde el hilo no principal puede ser analizada, y la salida puede realizarse de manera controlada.

Ejecutar este código 
#include <iostream>
#include <thread>
class foo
{
public:
    foo() { std::cerr << "foo::foo()\n"; }
    ~foo() { std::cerr << "foo::~foo()\n"; }
};
// Objeto estático, se espera el destructor al salir
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();
}

Salida: 

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

Véase también

función llamada cuando el manejo de excepciones falla
(función)
(C++11)
obtiene el terminate_handler actual
(función)
el tipo de la función llamada por std::terminate
(typedef)