Standard library header <exception>

< cpp‎ | header

This header is part of the error handling library.



base class for exceptions thrown by the standard library components
a mixin type to capture and store current exceptions
exception thrown when dynamic exception specification is violated, if possible


function called when dynamic exception specification is violated
the type of the function called by std::unexpected
the type of the function called by std::terminate
shared pointer type for handling exception objects


checks if exception handling is currently in progress
creates an std::exception_ptr from an exception object
(function template)
captures the current exception in a std::exception_ptr
throws the exception from an std::exception_ptr
throws its argument with std::nested_exception mixed in
(function template)
throws the exception from a std::nested_exception
(function template)
function called when exception handling fails
obtains the current terminate_handler
changes the function to be called by std::terminate
obtains the current unexpected_handler
changes the function to be called by std::unexpected

[edit] Synopsis

namespace std {
    class exception;
    class bad_exception;
    class nested_exception;
    typedef void (*unexpected_handler)();
    unexpected_handler get_unexpected() noexcept;
    unexpected_handler set_unexpected(unexpected_handler f) noexcept;
    [[noreturn]] void unexpected();
    typedef void (*terminate_handler)();
    terminate_handler get_terminate() noexcept;
    terminate_handler set_terminate(terminate_handler f) noexcept;
    [[noreturn]] void terminate() noexcept;
    bool uncaught_exception() noexcept;
    typedef /*unspecified*/ exception_ptr;
    exception_ptr current_exception() noexcept;
    [[noreturn]] void rethrow_exception(exception_ptr p);
    template<class E> exception_ptr make_exception_ptr(E e) noexcept;
    [[noreturn]] template <class T> void throw_with_nested(T&& t);
    template <class E> void rethrow_if_nested(const E& e);

[edit] Class std::exception

class exception {
    exception() noexcept;
    exception(const exception&) noexcept;
    exception& operator=(const exception&) noexcept;
    virtual ~exception();
    virtual const char* what() const noexcept;

[edit] Class std::bad_exception

class bad_exception : public exception {
    bad_exception() noexcept;
    bad_exception(const bad_exception&) noexcept;
    bad_exception& operator=(const bad_exception&) noexcept;
    virtual const char* what() const noexcept;

[edit] Class std::nested_exception

class nested_exception {
    nested_exception() noexcept;
    nested_exception(const nested_exception&) noexcept = default;
    nested_exception& operator=(const nested_exception&) noexcept = default;
    virtual ~nested_exception() = default;
    // access functions
    [[noreturn]] void rethrow_nested() const;
    exception_ptr nested_ptr() const noexcept;

[edit] See Also