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

Files changed (1) hide show

tmp/tmp7r2cl92p/{from.md → to.md} +49 -18

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

@@ -28,11 +28,13 @@ noexcept-specification:
 ```
 In a *noexcept-specification*, the *constant-expression*, if supplied,
 shall be a constant expression ([[expr.const]]) that is contextually
 converted to `bool` (Clause  [[conv]]). A *noexcept-specification*
-`noexcept` is equivalent to `noexcept({}true)`.
 An *exception-specification* shall appear only on a function declarator
 for a function type, pointer to function type, reference to function
 type, or pointer to member function type that is the top-level type of a
 declaration or definition, or on such a type appearing as a parameter or
@@ -45,16 +47,16 @@ void (*fp)() throw (int);               // OK
 void g(void pfa() throw(int));          // OK
 typedef int (*pf)() throw(int);         // ill-formed
 ```
 A type denoted in an *exception-specification* shall not denote an
-incomplete type. A type denoted in an *exception-specification* shall
-not denote a pointer or reference to an incomplete type, other than
-`void*`, `const` `void*`, `volatile` `void*`, or `const` `volatile`
-`void*`. A type cv `T`, “array of `T`”, or “function returning `T`”
-denoted in an *exception-specification* is adjusted to type `T`,
-“pointer to `T`”, or “pointer to function returning `T`”, respectively.
 Two *exception-specification*s are *compatible* if:
 - both are non-throwing (see below), regardless of their form,
 - both have the form `noexcept(`*constant-expression*`)` and the
@@ -188,37 +190,42 @@ yields `true`. A function with a non-throwing *exception-specification*
 does not allow any exceptions.
 An *exception-specification* is not considered part of a function’s
 type.
-An implicitly declared special member function (Clause  [[special]])
-shall have an *exception-specification*. If `f` is an implicitly
-declared default constructor, copy constructor, move constructor,
-destructor, copy assignment operator, or move assignment operator, its
-implicit *exception-specification* specifies the *type-id* `T` if and
-only if `T` is allowed by the *exception-specification* of a function
-directly invoked by `f`’s implicit definition; `f` shall allow all
 exceptions if any function it directly invokes allows all exceptions,
-and `f` shall allow no exceptions if every function it directly invokes
-allows no exceptions.
 ``` cpp
 struct A {
   A();
   A(const A&) throw();
   A(A&&) throw();
   ~A() throw(X);
 };
 struct B {
   B() throw();
-  B(const B&) throw();
   B(B&&) throw(Y);
   ~B() throw(Y);
 };
 struct D : public A, public B {
     // Implicit declaration of D::D();
-    // Implicit declaration of D::D(const D&) throw();
     // Implicit declaration of D::D(D&&) throw(Y);
     // Implicit declaration of D::~D() throw(X, Y);
 };
 ```
@@ -230,10 +237,34 @@ restrictive as that in the base class.
 A deallocation function ([[basic.stc.dynamic.deallocation]]) with no
 explicit *exception-specification* is treated as if it were specified
 with `noexcept(true)`.
 In a *dynamic-exception-specification*, a *type-id* followed by an
 ellipsis is a pack expansion ([[temp.variadic]]).
 The use of *dynamic-exception-specification*s is deprecated (see Annex
 [[depr]]).

 ```
 In a *noexcept-specification*, the *constant-expression*, if supplied,
 shall be a constant expression ([[expr.const]]) that is contextually
 converted to `bool` (Clause  [[conv]]). A *noexcept-specification*
+`noexcept` is equivalent to `noexcept(true)`. A `(` token that follows
+`noexcept` is part of the *noexcept-specification* and does not commence
+an initializer ([[dcl.init]]).
 An *exception-specification* shall appear only on a function declarator
 for a function type, pointer to function type, reference to function
 type, or pointer to member function type that is the top-level type of a
 declaration or definition, or on such a type appearing as a parameter or
 void g(void pfa() throw(int));          // OK
 typedef int (*pf)() throw(int);         // ill-formed
 ```
 A type denoted in an *exception-specification* shall not denote an
+incomplete type or an rvalue reference type. A type denoted in an
+*exception-specification* shall not denote a pointer or reference to an
+incomplete type, other than *cv* `void*`. A type cv `T`, “array of `T`”,
+or “function returning `T`” denoted in an *exception-specification* is
+adjusted to type `T`, “pointer to `T`”, or “pointer to function
+returning `T`”, respectively.
 Two *exception-specification*s are *compatible* if:
 - both are non-throwing (see below), regardless of their form,
 - both have the form `noexcept(`*constant-expression*`)` and the
 does not allow any exceptions.
 An *exception-specification* is not considered part of a function’s
 type.
+An inheriting constructor ([[class.inhctor]]) and an implicitly
+declared special member function (Clause  [[special]]) have an
+*exception-specification*. If `f` is an inheriting constructor or an
+implicitly declared default constructor, copy constructor, move
+constructor, destructor, copy assignment operator, or move assignment
+operator, its implicit *exception-specification* specifies the *type-id*
+`T` if and only if `T` is allowed by the *exception-specification* of a
+function directly invoked by `f`’s implicit definition; `f` allows all
 exceptions if any function it directly invokes allows all exceptions,
+and `f` has the *exception-specification* `noexcept(true)` if every
+function it directly invokes allows no exceptions. It follows that `f`
+has the *exception-specification* `noexcept(true)` if it invokes no
+other functions. An instantiation of an inheriting constructor template
+has an implied *exception-specification* as if it were a non-template
+inheriting constructor.
 ``` cpp
 struct A {
   A();
   A(const A&) throw();
   A(A&&) throw();
   ~A() throw(X);
 };
 struct B {
   B() throw();
+  B(const B&) = default; // Declaration of B::B(const B&) noexcept(true)
   B(B&&) throw(Y);
   ~B() throw(Y);
 };
 struct D : public A, public B {
     // Implicit declaration of D::D();
+    // Implicit declaration of D::D(const D&) noexcept(true);
     // Implicit declaration of D::D(D&&) throw(Y);
     // Implicit declaration of D::~D() throw(X, Y);
 };
 ```
 A deallocation function ([[basic.stc.dynamic.deallocation]]) with no
 explicit *exception-specification* is treated as if it were specified
 with `noexcept(true)`.
+An *exception-specification* is considered to be *needed* when:
+- in an expression, the function is the unique lookup result or the
+  selected member of a set of overloaded functions ([[basic.lookup]],
+  [[over.match]], [[over.over]]);
+- the function is odr-used ([[basic.def.odr]]) or, if it appears in an
+  unevaluated operand, would be odr-used if the expression were
+  potentially-evaluated;
+- the *exception-specification* is compared to that of another
+  declaration (e.g., an explicit specialization or an overriding virtual
+  function);
+- the function is defined; or
+- the *exception-specification* is needed for a defaulted special member
+  function that calls the function. A defaulted declaration does not
+  require the *exception-specification* of a base member function to be
+  evaluated until the implicit *exception-specification* of the derived
+  function is needed, but an explicit *exception-specification* needs
+  the implicit *exception-specification* to compare against.
+The *exception-specification* of a defaulted special member function is
+evaluated as described above only when needed; similarly, the
+*exception-specification* of a specialization of a function template or
+member function of a class template is instantiated only when needed.
 In a *dynamic-exception-specification*, a *type-id* followed by an
 ellipsis is a pack expansion ([[temp.variadic]]).
 The use of *dynamic-exception-specification*s is deprecated (see Annex
 [[depr]]).

Diff to HTML by rtfpessoa