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
(class) [edit]
a mixin type to capture and store current exceptions
(class) [edit]
exception thrown when std::current_exception fails to copy the exception object
(class) [edit]


(removed in C++17)
the type of the function called by std::unexpected
(typedef) [edit]
the type of the function called by std::terminate
(typedef) [edit]
shared pointer type for handling exception objects
(typedef) [edit]


(removed in C++17)
function called when dynamic exception specification is violated
(function) [edit]
checks if exception handling is currently in progress
(function) [edit]
creates an std::exception_ptr from an exception object
(function template) [edit]
captures the current exception in a std::exception_ptr
(function) [edit]
throws the exception from an std::exception_ptr
(function) [edit]
throws its argument with std::nested_exception mixed in
(function template) [edit]
throws the exception from a std::nested_exception
(function template) [edit]
function called when exception handling fails
(function) [edit]
obtains the current terminate_handler
(function) [edit]
changes the function to be called by std::terminate
(function) [edit]
(C++11)(removed in C++17)
obtains the current unexpected_handler
(function) [edit]
(removed in C++17)
changes the function to be called by std::unexpected
(function) [edit]

[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