[except.handle] - C++17 → C++20

Files changed (1) hide show

tmp/tmpc003t279/{from.md → to.md} +26 -25

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

@@ -16,23 +16,23 @@ A *handler* is a match for an exception object of type `E` if
 - The *handler* is of type cv `T` or cv `T&` and `E` and `T` are the
   same type (ignoring the top-level *cv-qualifier*s), or
 - the *handler* is of type cv `T` or cv `T&` and `T` is an unambiguous
   public base class of `E`, or
 - the *handler* is of type cv `T` or `const T&` where `T` is a pointer
-  or pointer to member type and `E` is a pointer or pointer to member
   type that can be converted to `T` by one or more of
-  - a standard pointer conversion ([[conv.ptr]]) not involving
- conversions to pointers to private or protected or ambiguous classes
-  - a function pointer conversion ([[conv.fctptr]])
-  - a qualification conversion ([[conv.qual]]), or
 - the *handler* is of type cv `T` or `const T&` where `T` is a pointer
-  or pointer to member type and `E` is `std::nullptr_t`.
 [*Note 1*: A *throw-expression* whose operand is an integer literal
-with value zero does not match a handler of pointer or pointer to member
 type. A handler of reference to array or function type is never a match
-for any exception object ([[expr.throw]]). — *end note*]
 [*Example 1*:
 ``` cpp
 class Matherr { ... virtual void vf(); };
@@ -72,44 +72,44 @@ try block.
 If no match is found among the handlers for a try block, the search for
 a matching handler continues in a dynamically surrounding try block of
 the same thread.
-A handler is considered active when initialization is complete for the
 parameter (if any) of the catch clause.
 [*Note 3*: The stack will have been unwound at that
 point. — *end note*]
-Also, an implicit handler is considered active when `std::terminate()`
-is entered due to a throw. A handler is no longer considered active when
-the catch clause exits.
 The exception with the most recently activated handler that is still
 active is called the *currently handled exception*.
-If no matching handler is found, the function `std::terminate()` is
 called; whether or not the stack is unwound before this call to
-`std::terminate()` is *implementation-defined* ([[except.terminate]]).
 Referring to any non-static member or base class of an object in the
 handler for a *function-try-block* of a constructor or destructor for
 that object results in undefined behavior.
 The scope and lifetime of the parameters of a function or constructor
 extend into the handlers of a *function-try-block*.
 Exceptions thrown in destructors of objects with static storage duration
 or in constructors of namespace-scope objects with static storage
-duration are not caught by a *function-try-block* on the `main`
-function ([[basic.start.main]]). Exceptions thrown in destructors of
-objects with thread storage duration or in constructors of
-namespace-scope objects with thread storage duration are not caught by a
-*function-try-block* on the initial function of the thread.
-If a return statement appears in a handler of the *function-try-block*
-of a constructor, the program is ill-formed.
 The currently handled exception is rethrown if control reaches the end
 of a handler of the *function-try-block* of a constructor or destructor.
 Otherwise, flowing off the end of the *compound-statement* of a
 *handler* of a *function-try-block* is equivalent to flowing off the end
@@ -117,18 +117,19 @@ of the *compound-statement* of that function (see [[stmt.return]]).
 The variable declared by the *exception-declaration*, of type cv `T` or
 cv `T&`, is initialized from the exception object, of type `E`, as
 follows:
-- if `T` is a base class of `E`, the variable is copy-initialized (
-  [[dcl.init]]) from the corresponding base class subobject of the
   exception object;
-- otherwise, the variable is copy-initialized ([[dcl.init]]) from the
   exception object.
 The lifetime of the variable ends when the handler exits, after the
-destruction of any automatic objects initialized within the handler.
 When the handler declares an object, any changes to that object will not
 affect the exception object. When the handler declares a reference to an
 object, any changes to the referenced object are changes to the
 exception object and will have effect should that object be rethrown.

 - The *handler* is of type cv `T` or cv `T&` and `E` and `T` are the
   same type (ignoring the top-level *cv-qualifier*s), or
 - the *handler* is of type cv `T` or cv `T&` and `T` is an unambiguous
   public base class of `E`, or
 - the *handler* is of type cv `T` or `const T&` where `T` is a pointer
+  or pointer-to-member type and `E` is a pointer or pointer-to-member
   type that can be converted to `T` by one or more of
+  - a standard pointer conversion [[conv.ptr]] not involving conversions
+    to pointers to private or protected or ambiguous classes
+  - a function pointer conversion [[conv.fctptr]]
+  - a qualification conversion [[conv.qual]], or
 - the *handler* is of type cv `T` or `const T&` where `T` is a pointer
+  or pointer-to-member type and `E` is `std::nullptr_t`.
 [*Note 1*: A *throw-expression* whose operand is an integer literal
+with value zero does not match a handler of pointer or pointer-to-member
 type. A handler of reference to array or function type is never a match
+for any exception object [[expr.throw]]. — *end note*]
 [*Example 1*:
 ``` cpp
 class Matherr { ... virtual void vf(); };
 If no match is found among the handlers for a try block, the search for
 a matching handler continues in a dynamically surrounding try block of
 the same thread.
+A handler is considered *active* when initialization is complete for the
 parameter (if any) of the catch clause.
 [*Note 3*: The stack will have been unwound at that
 point. — *end note*]
+Also, an implicit handler is considered active when the function
+`std::terminate` is entered due to a throw. A handler is no longer
+considered active when the catch clause exits.
 The exception with the most recently activated handler that is still
 active is called the *currently handled exception*.
+If no matching handler is found, the function `std::terminate` is
 called; whether or not the stack is unwound before this call to
+`std::terminate` is *implementation-defined* [[except.terminate]].
 Referring to any non-static member or base class of an object in the
 handler for a *function-try-block* of a constructor or destructor for
 that object results in undefined behavior.
 The scope and lifetime of the parameters of a function or constructor
 extend into the handlers of a *function-try-block*.
 Exceptions thrown in destructors of objects with static storage duration
 or in constructors of namespace-scope objects with static storage
+duration are not caught by a *function-try-block* on the `main` function
+[[basic.start.main]]. Exceptions thrown in destructors of objects with
+thread storage duration or in constructors of namespace-scope objects
+with thread storage duration are not caught by a *function-try-block* on
+the initial function of the thread.
+If a `return` statement [[stmt.return]] appears in a handler of the
+*function-try-block* of a constructor, the program is ill-formed.
 The currently handled exception is rethrown if control reaches the end
 of a handler of the *function-try-block* of a constructor or destructor.
 Otherwise, flowing off the end of the *compound-statement* of a
 *handler* of a *function-try-block* is equivalent to flowing off the end
 The variable declared by the *exception-declaration*, of type cv `T` or
 cv `T&`, is initialized from the exception object, of type `E`, as
 follows:
+- if `T` is a base class of `E`, the variable is copy-initialized
+  [[dcl.init]] from the corresponding base class subobject of the
   exception object;
+- otherwise, the variable is copy-initialized [[dcl.init]] from the
   exception object.
 The lifetime of the variable ends when the handler exits, after the
+destruction of any objects with automatic storage duration initialized
+within the handler.
 When the handler declares an object, any changes to that object will not
 affect the exception object. When the handler declares a reference to an
 object, any changes to the referenced object are changes to the
 exception object and will have effect should that object be rethrown.

Diff to HTML by rtfpessoa