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

Files changed (1) hide show

tmp/tmp3y_fbntr/{from.md → to.md} +48 -49

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

@@ -6,37 +6,41 @@ exceptions that can cause that *handler* to be entered. The
 class type, or an rvalue reference type. The *exception-declaration*
 shall not denote a pointer or reference to an incomplete type, other
 than `void*`, `const` `void*`, `volatile` `void*`, or `const` `volatile`
 `void*`.
-A handler of type “array of `T`” or “function returning `T`” is adjusted
-to be of type “pointer to `T`” or “pointer to function returning `T`”,
-respectively.
 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-qualifiers*), 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
-  type and `E` is a pointer type that can be converted to `T` by either
-  or both of
   - a standard pointer conversion ([[conv.ptr]]) not involving
     conversions to pointers to private or protected or ambiguous classes
-  - a qualification conversion, 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`.
-A *throw-expression* whose operand is an integer literal with value zero
-does not match a handler of pointer or pointer to member type.
 ``` cpp
-class Matherr { /* ... */ virtual void vf(); };
-class Overflow: public Matherr { /* ... */ };
-class Underflow: public Matherr { /* ... */ };
-class Zerodivide: public Matherr { /* ... */ };
 void f() {
   try {
     g();
   } catch (Overflow oo) {
@@ -50,14 +54,18 @@ void f() {
 Here, the `Overflow` handler will catch exceptions of type `Overflow`
 and the `Matherr` handler will catch exceptions of type `Matherr` and of
 all types publicly derived from `Matherr` including exceptions of type
 `Underflow` and `Zerodivide`.
-The handlers for a try block are tried in order of appearance. That
-makes it possible to write handlers that can never be executed, for
-example by placing a handler for a derived class after a handler for a
-corresponding base class.
 A `...` in a handler’s *exception-declaration* functions similarly to
 `...` in a function parameter declaration; it specifies a match for any
 exception. If present, a `...` handler shall be the last handler for its
 try block.
@@ -65,15 +73,18 @@ 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. The stack will have been unwound
-at that point. Also, an implicit handler is considered active when
-`std::terminate()` or `std::unexpected()` is entered due to a throw. A
-handler is no longer considered active when the catch clause exits or
-when `std::unexpected()` exits after being entered due to a throw.
 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
@@ -82,44 +93,32 @@ called; whether or not the stack is unwound before this call to
 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 fully constructed base classes and members of an object shall be
-destroyed before entering the handler of a *function-try-block* of a
-constructor for that object. Similarly, if a delegating constructor for
-an object exits with an exception after the non-delegating constructor
-for that object has completed execution, the object’s destructor shall
-be executed before entering the handler of a of a constructor for that
-object. The base classes and non-variant members of an object shall be
-destroyed before entering the handler of a of a destructor for that
-object ([[class.dtor]]).
 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 `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, a function returns when control reaches the end of a handler
-for the *function-try-block* ([[stmt.return]]). Flowing off the end of
-a *function-try-block* is equivalent to a `return` with no value; this
-results in undefined behavior in a value-returning function (
-[[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;

 class type, or an rvalue reference type. The *exception-declaration*
 shall not denote a pointer or reference to an incomplete type, other
 than `void*`, `const` `void*`, `volatile` `void*`, or `const` `volatile`
 `void*`.
+A handler of type “array of `T`” or function type `T` is adjusted to be
+of type “pointer to `T`”.
 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(); };
+class Overflow: public Matherr { ... };
+class Underflow: public Matherr { ... };
+class Zerodivide: public Matherr { ... };
 void f() {
   try {
     g();
   } catch (Overflow oo) {
 Here, the `Overflow` handler will catch exceptions of type `Overflow`
 and the `Matherr` handler will catch exceptions of type `Matherr` and of
 all types publicly derived from `Matherr` including exceptions of type
 `Underflow` and `Zerodivide`.
+— *end example*]
+The handlers for a try block are tried in order of appearance.
+[*Note 2*: This makes it possible to write handlers that can never be
+executed, for example by placing a handler for a final derived class
+after a handler for a corresponding unambiguous public base
+class. — *end note*]
 A `...` in a handler’s *exception-declaration* functions similarly to
 `...` in a function parameter declaration; it specifies a match for any
 exception. If present, a `...` handler shall be the last handler for its
 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
 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
+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;

Diff to HTML by rtfpessoa