Namespaces
Variants
Views
Actions

Difference between revisions of "cpp/error/set terminate"

From cppreference.com
< cpp‎ | error
m (Text replace - "{{cpp|" to "{{c|")
m (fmt)
 
(20 intermediate revisions by 13 users not shown)
Line 1: Line 1:
 
{{cpp/title|set_terminate}}
 
{{cpp/title|set_terminate}}
−
{{cpp/error/sidebar}}
+
{{cpp/error/navbar}}
−
{{ddcl list begin}}
+
{{dcl begin}}
−
{{ddcl list header | exception}}
+
{{dcl header|exception}}
−
{{ddcl list item | 1=
+
{{dcl rev multi|until1=c++11
−
std::terminate_handler set_terminate( std::terminate_handler f )
+
|dcl1=
 +
std::terminate_handler set_terminate( std::terminate_handler f ) throw();
 +
|dcl2=
 +
std::terminate_handler set_terminate( std::terminate_handler f ) noexcept;
 
}}
 
}}
−
{{ddcl list end}}
+
{{dcl end}}
  
−
Makes {{tt|f}} the new global terminate handler function and returns the previously installed {{c|std::terminate_handler}}.
+
Makes {{c|f}} the new global terminate handler function and returns the previously installed {{lc|std::terminate_handler}}. {{c|f}} shall terminate execution of the program without returning to its caller, otherwise the behavior is undefined.
 +
 
 +
{{rrev|since=c++11|
 +
This function is thread-safe. Every call to {{tt|std::set_terminate}} ''synchronizes-with'' (see {{lc|std::memory_order}}) subsequent calls to {{tt|std::set_terminate}} and {{lc|std::get_terminate}}.
 +
}}
  
 
===Parameters===
 
===Parameters===
−
{{param list begin}}
+
{{par begin}}
−
{{param list item | f | pointer to function of type {{c|std::terminate_handler}}, or null pointer}}
+
{{par|f|pointer to function of type {{lc|std::terminate_handler}}, or null pointer}}
−
{{param list end}}
+
{{par end}}
  
 
===Return value===
 
===Return value===
 
The previously-installed terminate handler, or a null pointer value if none was installed.
 
The previously-installed terminate handler, or a null pointer value if none was installed.
  
−
===Exceptions===
+
===Example===
−
{{noexcept}}
+
{{example
 +
|code=
 +
#include <cstdlib>
 +
#include <exception>
 +
#include <iostream>
 +
 
 +
int main()
 +
{
 +
    std::set_terminate([]()
 +
    {
 +
        std::cout << "Unhandled exception\n" << std::flush;
 +
        std::abort();
 +
    });
 +
    throw 1;
 +
}
 +
|p=true
 +
|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 {{c/core|try}}/{{c/core|catch}} block. In the following example, since the exception is unhandled, {{lc|std::terminate}} will be called.
 +
 
 +
{{example
 +
|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;
 +
}
 +
|p=true
 +
|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.
 +
 
 +
{{example
 +
|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===
 
===See also===
−
{{dcl list begin}}
+
{{dsc begin}}
−
{{dcl list template | cpp/error/exception/dcl list terminate}}
+
{{dsc inc|cpp/error/dsc terminate}}
−
{{dcl list template | cpp/error/exception/dcl list get_terminate}}
+
{{dsc inc|cpp/error/dsc get_terminate}}
−
{{dcl list template | cpp/error/exception/dcl list terminate_handler}}
+
{{dsc inc|cpp/error/dsc terminate_handler}}
−
{{dcl list end}}
+
{{dsc end}}
 +
 
 +
{{langlinks|de|es|fr|it|ja|pt|ru|zh}}

Latest revision as of 10:28, 9 July 2024

 
C++
 
Diagnostics library
 
Defined in header <exception>
(until C++11)
std::terminate_handler set_terminate( std::terminate_handler f ) noexcept;
 (since C++11)

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)

Contents

[edit] Parameters

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

[edit] Return value

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

[edit] 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()

[edit] 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]
Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/error/set_terminate&oldid=173429"