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

Files changed (1) hide show

tmp/tmpd066218m/{from.md → to.md} +29 -29

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

@@ -16,22 +16,21 @@ 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 *cv1* `T*` *cv2* and `E` is a pointer type
- that can be converted to the type of the *handler* 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
-- the *handler* is a pointer or pointer to member type and `E` is
-  `std::nullptr_t`.
-A *throw-expression* whose operand is an integral constant expression of
-integer type that evaluates to 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 { /* ... */ };
@@ -66,16 +65,15 @@ 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
-formal 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
@@ -116,21 +114,23 @@ 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]]).
-If the *exception-declaration* specifies a name, it declares a variable
-which is copy-initialized ([[dcl.init]]) from the exception object. If
-the *exception-declaration* denotes an object type but does not specify
-a name, a temporary ([[class.temporary]]) is copy-initialized (
-[[dcl.init]]) from the exception object. The lifetime of the variable or
-temporary ends when the handler exits, after the destruction of any
-automatic objects initialized within the handler.
-When the handler declares a non-constant object, any changes to that
-object will not affect the temporary object that was initialized by
-execution of the *throw-expression*. When the handler declares a
-reference to a non-constant object, any changes to the referenced object
-are changes to the temporary object initialized when the
-*throw-expression* was executed 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-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 { /* ... */ };
 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
 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;
+- 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.

Diff to HTML by rtfpessoa