[dcl.constexpr] - C++11 → C++14

Files changed (1) hide show

tmp/tmp3bnzi___/{from.md → to.md} +70 -114

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

@@ -1,32 +1,33 @@
 ### The `constexpr` specifier <a id="dcl.constexpr">[[dcl.constexpr]]</a>
 The `constexpr` specifier shall be applied only to the definition of a
-variable, the declaration of a function or function template, or the
-declaration of a static data member of a literal type (
-[[basic.types]]). If any declaration of a function or function template
-has `constexpr` specifier, then all its declarations shall contain the
-`constexpr` specifier. An explicit specialization can differ from the
-template declaration with respect to the `constexpr` specifier. Function
-parameters cannot be declared `constexpr`.
 ``` cpp
-constexpr int square(int x); // OK: declaration
 constexpr int bufsz = 1024;     // OK: definition
 constexpr struct pixel {        // error: pixel is a type
   int x;
   int y;
   constexpr pixel(int);         // OK: declaration
 };
 constexpr pixel::pixel(int a)
-  : x(square(a)), y(square(a))  // OK: definition
-  { }
 constexpr pixel small(2);       // error: square not defined, so small(2)
                                 // not constant~([expr.const]) so constexpr not satisfied
-constexpr int square(int x) { // OK: definition
- return x * x;
 }
 constexpr pixel large(4);       // OK: square defined
 int next(constexpr int x) {     // error: not for parameters
      return x + 1;
 }
@@ -45,122 +46,89 @@ constraints:
 - it shall not be virtual ([[class.virtual]]);
 - its return type shall be a literal type;
 - each of its parameter types shall be a literal type;
 - its *function-body* shall be `= delete`, `= default`, or a
-  *compound-statement* that contains only
-  - null statements,
-  -
-  - `typedef` declarations and *alias-declaration*s that do not define
-    classes or enumerations,
-  - *using-declaration*s,
-  - *using-directive*s,
-  - and exactly one return statement;
-- every constructor call and implicit conversion used in initializing
-  the return value ([[stmt.return]],  [[dcl.init]]) shall be one of
-  those allowed in a constant expression ([[expr.const]]).
 ``` cpp
 constexpr int square(int x)
   { return x * x; }             // OK
 constexpr long long_max()
   { return 2147483647; }        // OK
-constexpr int abs(int x)
- { return x < 0 ? -x : x; }    // OK
-constexpr void f(int x)         // error: return type is void
- { /* ... */ }
 constexpr int prev(int x)
-  { return --x; }               // error: use of decrement
-constexpr int g(int x, int n) { // error: body not just ``return expr''
   int r = 1;
   while (--n > 0) r *= x;
   return r;
 }
 ```
-In a definition of a `constexpr` constructor, each of the parameter
-types shall be a literal type. In addition, either its *function-body*
-shall be `= delete` or `= default` or it shall satisfy the following
 constraints:
 - the class shall not have any virtual base classes;
 - its *function-body* shall not be a *function-try-block*;
-- the *compound-statement* of its *function-body* shall contain only
-  - null statements,
- -
- - `typedef` declarations and *alias-declaration*s that do not define
-    classes or enumerations,
- - *using-declaration*s,
- - and *using-directive*s;
-- every non-static data member and base class sub-object shall be
-  initialized ([[class.base.init]]);
-- every constructor involved in initializing non-static data members and
- base class sub-objects shall be a `constexpr` constructor;
-- every *assignment-expression* that is an *initializer-clause*
- appearing directly or indirectly within a *brace-or-equal-initializer*
- for a non-static data member that is not named by a
-  *mem-initializer-id* shall be a constant expression; and
-- every implicit conversion used in converting a constructor argument to
-  the corresponding parameter type and converting a full-expression to
-  the corresponding member type shall be one of those allowed in a
-  constant expression.
 ``` cpp
 struct Length {
- explicit constexpr Length(int i = 0) : val(i) { }
 private:
   int val;
 };
 ```
-*Function invocation substitution* for a call of a `constexpr` function
-or of a `constexpr` constructor means implicitly converting each
-argument to the corresponding parameter type as if by
-copy-initialization,[^3] substituting that converted expression for each
-use of the corresponding parameter in the *function-body*, and, for
-`constexpr` functions, implicitly converting the resulting returned
-expression or *braced-init-list* to the return type of the function as
-if by copy-initialization. Such substitution does not change the
-meaning.
-``` cpp
-constexpr int f(void *) { return 0; }
-constexpr int f(...) { return 1; }
-constexpr int g1() { return f(0); }         // calls f(void *)
-constexpr int g2(int n) { return f(n); }    // calls f(...) even for n == 0
-constexpr int g3(int n) { return f(n*0); }  // calls f(...)
-namespace N {
-  constexpr int c = 5;
-  constexpr int h() { return c; }
-}
-constexpr int c = 0;
-constexpr int g4() { return N::h(); }       // value is 5, c is not looked up again after the substitution
-```
-For a `constexpr` function, if no function argument values exist such
-that the function invocation substitution would produce a constant
 expression ([[expr.const]]), the program is ill-formed; no diagnostic
-required. For a `constexpr` constructor, if no argument values exist
-such that after function invocation substitution, every constructor call
-and full-expression in the *mem-initializer*s would be a constant
-expression (including conversions), the program is ill-formed; no
-diagnostic required.
 ``` cpp
 constexpr int f(bool b)
   { return b ? throw 0 : 0; }               // OK
-constexpr int f() { throw 0; } // ill-formed, no diagnostic required
 struct B {
   constexpr B(int x) : i(0) { }             // x is unused
   int i;
 };
@@ -174,37 +142,25 @@ struct D : B {
 ```
 If the instantiated template specialization of a `constexpr` function
 template or member function of a class template would fail to satisfy
 the requirements for a `constexpr` function or `constexpr` constructor,
-that specialization is not a `constexpr` function or `constexpr`
-constructor. If the function is a member function it will still be
-`const` as described below. If no specialization of the template would
-yield a `constexpr` function or `constexpr` constructor, the program is
-ill-formed; no diagnostic required.
 A call to a `constexpr` function produces the same result as a call to
 an equivalent non-`constexpr` function in all respects except that a
 call to a `constexpr` function can appear in a constant expression.
-A `constexpr` specifier for a non-static member function that is not a
-constructor declares that member function to be `const` (
-[[class.mfct.non-static]]). The `constexpr` specifier has no other
-effect on the function type. The keyword `const` is ignored if it
-appears in the *cv-qualifier-seq* of the function declarator of the
-declaration of such a member function. The class of which that function
-is a member shall be a literal type ([[basic.types]]).
 ``` cpp
-class debug_flag {
-public:
-  explicit debug_flag(bool);
-  constexpr bool is_on();       // error: debug_flag not
-                                // literal type
-private:
-  bool flag;
-};
 constexpr int bar(int x, int y) // OK
     { return x + y + x*y; }
 // ...
 int bar(int x, int y)           // error: redefinition of bar
     { return x * 2 + 3 * y; }
@@ -215,12 +171,12 @@ object as `const`. Such an object shall have literal type and shall be
 initialized. If it is initialized by a constructor call, that call shall
 be a constant expression ([[expr.const]]). Otherwise, or if a
 `constexpr` specifier is used in a reference declaration, every
 full-expression that appears in its initializer shall be a constant
 expression. Each implicit conversion used in converting the initializer
-expressions and each constructor call used for the initialization shall
-be one of those allowed in a constant expression ([[expr.const]]).
 ``` cpp
 struct pixel {
   int x, y;
 };

 ### The `constexpr` specifier <a id="dcl.constexpr">[[dcl.constexpr]]</a>
 The `constexpr` specifier shall be applied only to the definition of a
+variable or variable template, the declaration of a function or function
+template, or the declaration of a static data member of a literal type (
+[[basic.types]]). If any declaration of a function, function template,
+or variable template has a `constexpr` specifier, then all its
+declarations shall contain the `constexpr` specifier. An explicit
+specialization can differ from the template declaration with respect to
+the `constexpr` specifier. Function parameters cannot be declared
+`constexpr`.
 ``` cpp
+constexpr void square(int &x); // OK: declaration
 constexpr int bufsz = 1024;     // OK: definition
 constexpr struct pixel {        // error: pixel is a type
   int x;
   int y;
   constexpr pixel(int);         // OK: declaration
 };
 constexpr pixel::pixel(int a)
+  : x(a), y(x) // OK: definition
+  { square(x); }
 constexpr pixel small(2);       // error: square not defined, so small(2)
                                 // not constant~([expr.const]) so constexpr not satisfied
+constexpr void square(int &x) { // OK: definition
+  x *= x;
 }
 constexpr pixel large(4);       // OK: square defined
 int next(constexpr int x) {     // error: not for parameters
      return x + 1;
 }
 - it shall not be virtual ([[class.virtual]]);
 - its return type shall be a literal type;
 - each of its parameter types shall be a literal type;
 - its *function-body* shall be `= delete`, `= default`, or a
+  *compound-statement* that does not contain
+  - an *asm-definition*,
+  - a `goto` statement,
+  - a *try-block*, or
+  - a definition of a variable of non-literal type or of static or
+    thread storage duration or for which no initialization is performed.
 ``` cpp
 constexpr int square(int x)
   { return x * x; }             // OK
 constexpr long long_max()
   { return 2147483647; }        // OK
+constexpr int abs(int x) {
+ if (x < 0)
+ x = -x;
+ return x;                     // OK
+}
+constexpr int first(int n) {
+  static int value = n;         // error: variable has static storage duration
+  return value;
+}
+constexpr int uninit() {
+  int a;                        // error: variable is uninitialized
+  return a;
+}
 constexpr int prev(int x)
+  { return --x; }               // OK
+constexpr int g(int x, int n) { // OK
   int r = 1;
   while (--n > 0) r *= x;
   return r;
 }
 ```
+The definition of a `constexpr` constructor shall satisfy the following
 constraints:
 - the class shall not have any virtual base classes;
+- each of the parameter types shall be a literal type;
 - its *function-body* shall not be a *function-try-block*;
+In addition, either its *function-body* shall be `= delete`, or it shall
+satisfy the following constraints:
+- either its *function-body* shall be `= default`, or the
+  *compound-statement* of its *function-body* shall satisfy the
+  constraints for a *function-body* of a `constexpr` function;
+- every non-variant non-static data member and base class sub-object
+  shall be initialized ([[class.base.init]]);
+- if the class is a union having variant members ([[class.union]]),
+  exactly one of them shall be initialized;
+- if the class is a union-like class, but is not a union, for each of
+  its anonymous union members having variant members, exactly one of
+ them shall be initialized;
+- for a non-delegating constructor, every constructor selected to
+ initialize non-static data members and base class sub-objects shall be
+  a `constexpr` constructor;
+- for a delegating constructor, the target constructor shall be a
+  `constexpr` constructor.
 ``` cpp
 struct Length {
+  constexpr explicit Length(int i = 0) : val(i) { }
 private:
   int val;
 };
 ```
+For a non-template, non-defaulted `constexpr` function or a
+non-template, non-defaulted, non-inheriting `constexpr` constructor, if
+no argument values exist such that an invocation of the function or
+constructor could be an evaluated subexpression of a core constant
 expression ([[expr.const]]), the program is ill-formed; no diagnostic
+required.
 ``` cpp
 constexpr int f(bool b)
   { return b ? throw 0 : 0; }               // OK
+constexpr int f() { return f(true); } // ill-formed, no diagnostic required
 struct B {
   constexpr B(int x) : i(0) { }             // x is unused
   int i;
 };
 ```
 If the instantiated template specialization of a `constexpr` function
 template or member function of a class template would fail to satisfy
 the requirements for a `constexpr` function or `constexpr` constructor,
+that specialization is still a `constexpr` function or `constexpr`
+constructor, even though a call to such a function cannot appear in a
+constant expression. If no specialization of the template would satisfy
+the requirements for a `constexpr` function or `constexpr` constructor
+when considered as a non-template function or constructor, the template
+is ill-formed; no diagnostic required.
 A call to a `constexpr` function produces the same result as a call to
 an equivalent non-`constexpr` function in all respects except that a
 call to a `constexpr` function can appear in a constant expression.
+The `constexpr` specifier has no effect on the type of a `constexpr`
+function or a `constexpr` constructor.
 ``` cpp
 constexpr int bar(int x, int y) // OK
     { return x + y + x*y; }
 // ...
 int bar(int x, int y)           // error: redefinition of bar
     { return x * 2 + 3 * y; }
 initialized. If it is initialized by a constructor call, that call shall
 be a constant expression ([[expr.const]]). Otherwise, or if a
 `constexpr` specifier is used in a reference declaration, every
 full-expression that appears in its initializer shall be a constant
 expression. Each implicit conversion used in converting the initializer
+expressions and each constructor call used for the initialization is
+part of such a full-expression.
 ``` cpp
 struct pixel {
   int x, y;
 };

Diff to HTML by rtfpessoa