std::set_terminate(3)

NAME
std::set_terminate - std::set_terminate

Synopsis
   Defined in header <exception>
   std::terminate_handler set_terminate( std::terminate_handler f ) (until C++11)
   throw();
   std::terminate_handler set_terminate( std::terminate_handler f ) (since C++11)
   noexcept;
   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 (since C++11)
   std::set_terminate and std::get_terminate.

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& exc)
     {
         std::cerr << "Exception: " << exc.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& exc)
         {
             std::cerr << "Exception: " << exc.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
   terminate function called when exception handling fails
                     (function)
   get_terminate obtains the current terminate_handler
   (C++11) (function)
   terminate_handler the type of the function called by std::terminate
                     (typedef)