[support.exception] - C++17 → C++20

Files changed (1) hide show

tmp/tmp2_zmnh3w/{from.md → to.md} +33 -56

tmp/tmp2_zmnh3w/{from.md → to.md} RENAMED Viewed

@@ -27,12 +27,10 @@ namespace std {
   template<class T> [[noreturn]] void throw_with_nested(T&& t);
   template<class E> void rethrow_if_nested(const E& e);
 }
 ```
-  [[except.special]].
 ### Class `exception` <a id="exception">[[exception]]</a>
 ``` cpp
 namespace std {
   class exception {
@@ -48,33 +46,32 @@ namespace std {
 The class `exception` defines the base class for the types of objects
 thrown as exceptions by C++ standard library components, and certain
 expressions, to report errors detected during program execution.
-Each standard library class `T` that derives from class `exception`
-shall have a publicly accessible copy constructor and a publicly
-accessible copy assignment operator that do not exit with an exception.
-These member functions shall meet the following postcondition: If two
-objects `lhs` and `rhs` both have dynamic type `T` and `lhs` is a copy
-of `rhs`, then `strcmp(lhs.what(), rhs.what())` shall equal 0.
-``` cpp
-exception() noexcept;
-```
-*Effects:* Constructs an object of class `exception`.
 ``` cpp
 exception(const exception& rhs) noexcept;
 exception& operator=(const exception& rhs) noexcept;
 ```
-*Effects:* Copies an `exception` object.
-*Postconditions:* If `*this` and `rhs` both have dynamic type
-`exception` then the value of the expression
-`strcmp(what(), rhs.what())` shall equal 0.
 ``` cpp
 virtual ~exception();
 ```
@@ -85,58 +82,39 @@ virtual const char* what() const noexcept;
 ```
 *Returns:* An *implementation-defined* NTBS.
 *Remarks:* The message may be a null-terminated multibyte
-string ([[multibyte.strings]]), suitable for conversion and display as
-a `wstring` ([[string.classes]], [[locale.codecvt]]). The return value
 remains valid until the exception object from which it is obtained is
 destroyed or a non-`const` member function of the exception object is
 called.
 ### Class `bad_exception` <a id="bad.exception">[[bad.exception]]</a>
 ``` cpp
 namespace std {
   class bad_exception : public exception {
   public:
- bad_exception() noexcept;
-    bad_exception(const bad_exception&) noexcept;
-    bad_exception& operator=(const bad_exception&) noexcept;
     const char* what() const noexcept override;
   };
 }
 ```
 The class `bad_exception` defines the type of the object referenced by
-the `exception_ptr` returned from a call to `current_exception` (
-[[propagation]]) when the currently active exception object fails to
 copy.
-``` cpp
-bad_exception() noexcept;
-```
-*Effects:* Constructs an object of class `bad_exception`.
-``` cpp
-bad_exception(const bad_exception&) noexcept;
-bad_exception& operator=(const bad_exception&) noexcept;
-```
-*Effects:* Copies an object of class `bad_exception`.
 ``` cpp
 const char* what() const noexcept override;
 ```
 *Returns:* An *implementation-defined* NTBS.
-*Remarks:* The message may be a null-terminated multibyte
-string ([[multibyte.strings]]), suitable for conversion and display as
-a `wstring` ([[string.classes]], [[locale.codecvt]]).
 ### Abnormal termination <a id="exception.terminate">[[exception.terminate]]</a>
 #### Type `terminate_handler` <a id="terminate.handler">[[terminate.handler]]</a>
 ``` cpp
@@ -181,12 +159,12 @@ terminate_handler get_terminate() noexcept;
 ``` cpp
 [[noreturn]] void terminate() noexcept;
 ```
 *Remarks:* Called by the implementation when exception handling must be
-abandoned for any of several reasons ([[except.terminate]]). May also
-be called directly by the program.
 *Effects:* Calls a `terminate_handler` function. It is unspecified which
 `terminate_handler` function will be called if an exception is active
 during a call to `set_terminate`. Otherwise calls the current
 `terminate_handler` function.
@@ -198,26 +176,25 @@ callable handler in this context. — *end note*]
 ``` cpp
 int uncaught_exceptions() noexcept;
 ```
-*Returns:* The number of uncaught exceptions ([[except.uncaught]]).
 *Remarks:* When `uncaught_exceptions() > 0`, throwing an exception can
-result in a call of
-`std::terminate()` ([[except.terminate]]).
 ### Exception propagation <a id="propagation">[[propagation]]</a>
 ``` cpp
 using exception_ptr = unspecified;
 ```
 The type `exception_ptr` can be used to refer to an exception object.
-`exception_ptr` shall satisfy the requirements of
-`NullablePointer` ([[nullablepointer.requirements]]).
 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
@@ -244,14 +221,14 @@ introduce a data race. — *end note*]
 ``` cpp
 exception_ptr current_exception() noexcept;
 ```
 *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.
@@ -269,11 +246,11 @@ to avoid infinite recursion. — *end note*]
 ``` cpp
 [[noreturn]] void rethrow_exception(exception_ptr p);
 ```
-*Requires:* `p` shall not be a null pointer.
 *Throws:* The exception object to which `p` refers.
 ``` cpp
 template<class E> exception_ptr make_exception_ptr(E e) noexcept;
@@ -332,12 +309,12 @@ returned value.
 ``` cpp
 [[noreturn]] void rethrow_nested() const;
 ```
 *Effects:* If `nested_ptr()` returns a null pointer, the function calls
-`std::terminate()`. Otherwise, it throws the stored exception captured
-by `*this`.
 ``` cpp
 exception_ptr nested_ptr() const noexcept;
 ```
@@ -348,11 +325,11 @@ object.
 template<class T> [[noreturn]] void throw_with_nested(T&& t);
 ```
 Let `U` be `decay_t<T>`.
-*Requires:* `U` shall be `CopyConstructible`.
 *Throws:* If
 `is_class_v<U> && !is_final_v<U> && !is_base_of_v<nested_exception, U>`
 is `true`, an exception of unspecified type that is publicly derived
 from both `U` and `nested_exception` and constructed from

   template<class T> [[noreturn]] void throw_with_nested(T&& t);
   template<class E> void rethrow_if_nested(const E& e);
 }
 ```
 ### Class `exception` <a id="exception">[[exception]]</a>
 ``` cpp
 namespace std {
   class exception {
 The class `exception` defines the base class for the types of objects
 thrown as exceptions by C++ standard library components, and certain
 expressions, to report errors detected during program execution.
+Each standard library class `T` that derives from class `exception` has
+the following publicly accessible member functions, each of them having
+a non-throwing exception specification [[except.spec]]:
+- default constructor (unless the class synopsis shows other
+  constructors)
+- copy constructor
+- copy assignment operator
+The copy constructor and the copy assignment operator meet the following
+postcondition: If two objects `lhs` and `rhs` both have dynamic type `T`
+and `lhs` is a copy of `rhs`, then `strcmp(lhs.what(), rhs.what())` is
+equal to `0`. The `what()` member function of each such `T` satisfies
+the constraints specified for `exception::what()` (see below).
 ``` cpp
 exception(const exception& rhs) noexcept;
 exception& operator=(const exception& rhs) noexcept;
 ```
+*Ensures:* If `*this` and `rhs` both have dynamic type `exception` then
+the value of the expression `strcmp(what(), rhs.what())` shall equal 0.
 ``` cpp
 virtual ~exception();
 ```
 ```
 *Returns:* An *implementation-defined* NTBS.
 *Remarks:* The message may be a null-terminated multibyte
+string [[multibyte.strings]], suitable for conversion and display as a
+`wstring` ([[string.classes]], [[locale.codecvt]]). The return value
 remains valid until the exception object from which it is obtained is
 destroyed or a non-`const` member function of the exception object is
 called.
 ### Class `bad_exception` <a id="bad.exception">[[bad.exception]]</a>
 ``` cpp
 namespace std {
   class bad_exception : public exception {
   public:
+ // see [exception] for the specification of the special member functions
     const char* what() const noexcept override;
   };
 }
 ```
 The class `bad_exception` defines the type of the object referenced by
+the `exception_ptr` returned from a call to `current_exception`
+[[propagation]] when the currently active exception object fails to
 copy.
 ``` cpp
 const char* what() const noexcept override;
 ```
 *Returns:* An *implementation-defined* NTBS.
 ### Abnormal termination <a id="exception.terminate">[[exception.terminate]]</a>
 #### Type `terminate_handler` <a id="terminate.handler">[[terminate.handler]]</a>
 ``` cpp
 ``` cpp
 [[noreturn]] void terminate() noexcept;
 ```
 *Remarks:* Called by the implementation when exception handling must be
+abandoned for any of several reasons [[except.terminate]]. May also be
+called directly by the program.
 *Effects:* Calls a `terminate_handler` function. It is unspecified which
 `terminate_handler` function will be called if an exception is active
 during a call to `set_terminate`. Otherwise calls the current
 `terminate_handler` function.
 ``` cpp
 int uncaught_exceptions() noexcept;
 ```
+*Returns:* The number of uncaught exceptions [[except.uncaught]].
 *Remarks:* When `uncaught_exceptions() > 0`, throwing an exception can
+result in a call of the function `std::terminate` [[except.terminate]].
 ### Exception propagation <a id="propagation">[[propagation]]</a>
 ``` cpp
 using exception_ptr = unspecified;
 ```
 The type `exception_ptr` can be used to refer to an exception object.
+`exception_ptr` meets the requirements of *Cpp17NullablePointer*
+([[cpp17.nullablepointer]]).
 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
 ``` cpp
 exception_ptr current_exception() noexcept;
 ```
 *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.
 ``` cpp
 [[noreturn]] void rethrow_exception(exception_ptr p);
 ```
+*Preconditions:* `p` is not a null pointer.
 *Throws:* The exception object to which `p` refers.
 ``` cpp
 template<class E> exception_ptr make_exception_ptr(E e) noexcept;
 ``` cpp
 [[noreturn]] void rethrow_nested() const;
 ```
 *Effects:* If `nested_ptr()` returns a null pointer, the function calls
+the function `std::terminate`. Otherwise, it throws the stored exception
+captured by `*this`.
 ``` cpp
 exception_ptr nested_ptr() const noexcept;
 ```
 template<class T> [[noreturn]] void throw_with_nested(T&& t);
 ```
 Let `U` be `decay_t<T>`.
+*Preconditions:* `U` meets the *Cpp17CopyConstructible* requirements.
 *Throws:* If
 `is_class_v<U> && !is_final_v<U> && !is_base_of_v<nested_exception, U>`
 is `true`, an exception of unspecified type that is publicly derived
 from both `U` and `nested_exception` and constructed from

Diff to HTML by rtfpessoa