Standard library header <exception>

From cppreference.com

This header is part of the error handling library.

Contents

Classes

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

Typedefs

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

Functions

checks if exception handling is currently in progress
(function)
creates an std::exception_ptr from an exception object
(function template)
captures the current exception in a std::exception_ptr
(function)
throws the exception from an std::exception_ptr
(function)
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
(function)
obtains the current terminate_handler
(function)
changes the function to be called by std::terminate
(function)
(C++11)(deprecated)
obtains the current unexpected_handler
(function)
(deprecated)
changes the function to be called by std::unexpected
(function)

[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 {
public:
    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 {
public:
    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 {
public:
    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