Namespaces
Variants

    std::set_terminate

    From cppreference.com
     
    C++
     
    Diagnostics library
     
    Defined in header <exception>
    std::terminate_handler set_terminate( std::terminate_handler f ) throw();
    		 (until C++11)
    std::terminate_handler set_terminate( std::terminate_handler f ) noexcept;
    		 (since C++11)
    See More

    Makes f the new global terminate handler function and returns the previously installed std::terminate_handler. f shall terminate execution of the program without returning to its caller, otherwise the behavior is undefined.

    This function is thread-safe. Every call to std::set_terminate synchronizes-with (see std::memory_order) subsequent calls to std::set_terminate and std::get_terminate.

    		(since C++11)

    Parameters

    f - pointer to function of type std::terminate_handler, or null pointer

    Return value

    The previously-installed terminate handler, or a null pointer value if none was installed.

    Example

    Run this code
    #include <cstdlib>
#include <exception>
#include <iostream>

int main()
{
    std::set_terminate([]()
    {
        std::cout << "Unhandled exception\n" << std::flush;
        std::abort();
    });
    throw 1;
}

    Possible output: 

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

    The terminate handler will also work for launched threads, so it can be used as an alternative to wrapping the thread function with a try/catch block. In the following example, since the exception is unhandled, std::terminate will be called.

    Run this code
    #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;
}

    Possible output: 

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

    With the introduction of the terminate handler, the exception thrown from the non-main thread can be analyzed, and exit can be gracefully performed.

    Run this code
    #include <iostream>
#include <thread>

class foo
{
public:
    foo() { std::cerr << "foo::foo()\n"; }
    ~foo() { std::cerr << "foo::~foo()\n"; }
};

// Static object, expecting destructor on exit
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();
}

    Output: 

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

    See also

    		 function called when exception handling fails
    (function) [edit]
    (C++11)
    		 obtains the current terminate_handler
    (function) [edit]
    		the type of the function called by std::terminate
    (typedef) [edit]