17 Language support library [support]

17.9 Exception handling [support.exception]

17.9.7 Exception propagation [propagation]

using exception_ptr = unspecified;
The type exception_­ptr can be used to refer to an exception object.
exception_­ptr meets the requirements of Cpp17NullablePointer (Table 37).
Two non-null values of type exception_­ptr are equivalent and compare equal if and only if they refer to the same exception.
The default constructor of exception_­ptr produces the null value of the type.
exception_­ptr shall not be implicitly convertible to any arithmetic, enumeration, or pointer type.
[Note 1:
An implementation can use a reference-counted smart pointer as exception_­ptr.
— end note]
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 2:
If rethrow_­exception rethrows the same exception object (rather than a copy), concurrent access to that rethrown exception object can 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;
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 is allowed to substitute a bad_­exception object to avoid infinite recursion.
— end note]
[[noreturn]] void rethrow_exception(exception_ptr p);
Preconditions: p is not a null pointer.
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> 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]