21 Language support library [language.support]

21.8 Exception handling [support.exception]

21.8.6 Exception propagation [propagation]

using exception_ptr = unspecified;
1
#
The type exception_­ptr can be used to refer to an exception object.
2
#
exception_­ptr shall satisfy the requirements of NullablePointer ([nullablepointer.requirements]).
3
#
Two non-null values of type exception_­ptr are equivalent and compare equal if and only if they refer to the same exception.
4
#
The default constructor of exception_­ptr produces the null value of the type.
5
#
exception_­ptr shall not be implicitly convertible to any arithmetic, enumeration, or pointer type.
6
#
[ Note
:
An implementation might use a reference-counted smart pointer as exception_­ptr.
— end note
 ]
7
#
For purposes of determining the presence of a data race, operations on exception_­ptr objects shall access and modify only the exception_­ptr objects themselves and not the exceptions they refer to.
Use of rethrow_­exception on exception_­ptr objects that refer to the same exception object shall not introduce a data race.
[ Note
:
If rethrow_­exception rethrows the same exception object (rather than a copy), concurrent access to that rethrown exception object may introduce a data race.
Changes in the number of exception_­ptr objects that refer to a particular exception do not introduce a data race.
— end note
 ]
exception_ptr current_exception() noexcept;
8
#
Returns: An exception_­ptr object that refers to the currently handled exception ([except.handle]) 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
:
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
:
The copy constructor of the thrown exception may also fail, so the implementation is allowed to substitute a bad_­exception object to avoid infinite recursion.
— end note
 ]
[[noreturn]] void rethrow_exception(exception_ptr p);
9
#
Requires: p shall not be a null pointer.
10
#
Throws: The exception object to which p refers.
template<class E> exception_ptr make_exception_ptr(E e) noexcept;
11
#
Effects: Creates an exception_­ptr object that refers to a copy of e, as if: 
try {
  throw e;
} catch(...) {
  return current_exception();
}
12
#
[ Note
:
This function is provided for convenience and efficiency reasons.
— end note
 ]