Returns: An
exception_ptr object that refers to the
currently handled exception
or a copy of the currently
handled exception, or a null
exception_ptr object if no exception is being
handled
. The referenced object shall remain valid at least as long as there is an
exception_ptr object that refers to it
.If the function needs to allocate memory and the attempt fails, it returns an
exception_ptr object that refers to an instance of
bad_alloc.It is unspecified whether the return values of two successive calls to
current_exception refer to the same exception object
.[
Note 3:
That is, it is unspecified whether
current_exception
creates a new copy each time it is called
. —
end note]
If the attempt to copy the current exception object throws an exception, the function
returns an
exception_ptr object that refers to the thrown exception or,
if this is not possible, to an instance of
bad_exception.[
Note 4:
The copy constructor of the thrown exception can also fail,
so the implementation can substitute a
bad_exception object
to avoid infinite recursion
. —
end note]
[[noreturn]] constexpr void rethrow_exception(exception_ptr p);
Effects: Let
u be the exception object to which
p refers, or
a copy of that exception object
. It is unspecified whether a copy is made, and
memory for the copy is allocated in an unspecified way
.- If allocating memory to form u fails,
throws an instance of bad_alloc;
- otherwise, if copying the exception to which p refers
to form u throws an exception, throws that exception;
- otherwise, throws u.
template<class E> constexpr exception_ptr make_exception_ptr(E e) noexcept;
Effects: Creates an exception_ptr object that refers to a copy of e, as if:
try {
throw e;
} catch(.) {
return current_exception();
}
[
Note 5:
This function is provided for convenience and
efficiency reasons
. —
end note]
template<class E> constexpr const E* exception_ptr_cast(const exception_ptr& p) noexcept;
Mandates:
E is a cv-unqualified complete object type
. E is not a pointer or pointer-to-member type
. [
Note 6:
When
E is a pointer or pointer-to-member type,
a handler of type
const E& can match
without binding to the exception object itself
. —
end note]
Returns: A pointer to the exception object referred to by
p,
if
p is not null and
a handler of type
const E&
would be a match (
[except.handle]) for that exception object
.