• Log in

// all freestanding
namespace std {
 class exception;
 class bad_exception;
 class nested_exception;
 
 using terminate_handler = void (*)();
 terminate_handler get_terminate() noexcept;
 terminate_handler set_terminate(terminate_handler f) noexcept;
 [[noreturn]] void terminate() noexcept;
 
 constexpr int uncaught_exceptions() noexcept;
 
 using exception_ptr = /* unspecified */;
 
 constexpr exception_ptr current_exception() noexcept;
 [[noreturn]] constexpr void rethrow_exception(exception_ptr p);
 template<class E> constexpr exception_ptr make_exception_ptr(E e) noexcept;
 
 template<class T> [[noreturn]] constexpr void throw_with_nested(T&& t);
 template<class E> constexpr void rethrow_if_nested(const E& e);
}

namespace std {
 class exception
 {
 public:
 constexpr exception() noexcept;
 constexpr exception(const exception&) noexcept;
 constexpr exception& operator=(const exception&) noexcept;
 constexpr virtual ~exception();
 constexpr virtual const char* what() const noexcept;
 };
}

namespace std {
 class bad_exception : public exception
 {
 public:
 // see description for the specification of the special member functions
 constexpr const char* what() const noexcept override;
 };
}

namespace std {
 class nested_exception
 {
 public:
 constexpr nested_exception() noexcept;
 constexpr nested_exception(const nested_exception&) noexcept = default;
 constexpr nested_exception& operator=(const nested_exception&) noexcept = default;
 constexpr virtual ~nested_exception() = default;
 
 // access functions
 [[noreturn]] constexpr void rethrow_nested() const;
 constexpr exception_ptr nested_ptr() const noexcept;
 };
 
 template<class T> [[noreturn]] constexpr void throw_with_nested(T&& t);
 template<class E> constexpr void rethrow_if_nested(const E& e);
}