[dcl.constexpr] - C++17 → C++20

Files changed (1) hide show

tmp/tmpt6k_s0bk/{from.md → to.md} +64 -61

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

@@ -1,17 +1,20 @@
-### 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 or the declaration of a function or
-function template. A function or static data member declared with the
-`constexpr` specifier is implicitly an inline function or variable (
-[[dcl.inline]]). If any declaration of a function or function template
-has a `constexpr` specifier, then all its declarations shall contain the
-`constexpr` specifier.
 [*Note 1*: An explicit specialization can differ from the template
-declaration with respect to the `constexpr` specifier. — *end note*]
 [*Note 2*: Function parameters cannot be declared
 `constexpr`. — *end note*]
 [*Example 1*:
@@ -26,11 +29,11 @@ constexpr struct pixel {        // error: pixel is a type
 };
 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
@@ -40,29 +43,33 @@ int next(constexpr int x) {     // error: not for parameters
 extern constexpr int memsz;     // error: not a definition
 ```
 — *end example*]
-A `constexpr` specifier used in the declaration of a function that is
-not a constructor declares that function to be a *constexpr function*.
-Similarly, a `constexpr` specifier used in a constructor declaration
-declares that constructor to be a *constexpr constructor*.
 The definition of a constexpr function shall satisfy the following
 requirements:
-- 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,
-  - an identifier label ([[stmt.label]]),
-  - 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.
 [*Example 2*:
 ``` cpp
 constexpr int square(int x)
@@ -77,12 +84,12 @@ constexpr int abs(int x) {
 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;
@@ -91,30 +98,13 @@ constexpr int g(int x, int n) { // OK
 }
 ```
 — *end example*]
-The definition of a constexpr constructor shall satisfy the following
-requirements:
-- 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 requirements:
-- either its *function-body* shall be `= default`, or the
-  *compound-statement* of its *function-body* shall satisfy the
-  requirements for a *function-body* of a constexpr function;
-- every non-variant non-static data member and base class subobject
-  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 subobjects shall be
   a constexpr constructor;
 - for a delegating constructor, the target constructor shall be a
   constexpr constructor.
@@ -129,16 +119,23 @@ private:
 };
 ```
 — *end example*]
 For a constexpr function or constexpr constructor that is neither
 defaulted nor a template, 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]]), or, for a
-constructor, a constant initializer for some object (
-[[basic.start.static]]), the program is ill-formed, no diagnostic
 required.
 [*Example 4*:
 ``` cpp
@@ -161,27 +158,33 @@ struct D : B {
 — *end example*]
 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 (
-  [[expr.const]]) and
-- copy elision is mandatory in a constant expression ([[class.copy]]).
-The `constexpr` specifier has no effect on the type of a constexpr
-function or a constexpr constructor.
 [*Example 5*:
 ``` cpp
 constexpr int bar(int x, int y)         // OK
@@ -192,14 +195,14 @@ int bar(int x, int y)                   // error: redefinition of bar
 ```
 — *end example*]
 A `constexpr` specifier used in an object declaration declares the
-object as `const`. Such an object shall have literal type and shall be
 initialized. In any `constexpr` variable declaration, the
-full-expression of the initialization shall be a constant expression (
-[[expr.const]]).
 [*Example 6*:
 ``` cpp
 struct pixel {

+### The `constexpr` and `consteval` specifiers <a id="dcl.constexpr">[[dcl.constexpr]]</a>
 The `constexpr` specifier shall be applied only to the definition of a
 variable or variable template or the declaration of a function or
+function template. The `consteval` specifier shall be applied only to
+the declaration of a function or function template. A function or static
+data member declared with the `constexpr` or `consteval` specifier is
+implicitly an inline function or variable [[dcl.inline]]. If any
+declaration of a function or function template has a `constexpr` or
+`consteval` specifier, then all its declarations shall contain the same
+specifier.
 [*Note 1*: An explicit specialization can differ from the template
+declaration with respect to the `constexpr` or `consteval`
+specifier. — *end note*]
 [*Note 2*: Function parameters cannot be declared
 `constexpr`. — *end note*]
 [*Example 1*:
 };
 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
 extern constexpr int memsz;     // error: not a definition
 ```
 — *end example*]
+A `constexpr` or `consteval` specifier used in the declaration of a
+function declares that function to be a *constexpr function*. A function
+or constructor declared with the `consteval` specifier is called an
+*immediate function*. A destructor, an allocation function, or a
+deallocation function shall not be declared with the `consteval`
+specifier.
 The definition of a constexpr function shall satisfy the following
 requirements:
+- its return type (if any) shall be a literal type;
 - each of its parameter types shall be a literal type;
+- it shall not be a coroutine [[dcl.fct.def.coroutine]];
+- if the function is a constructor or destructor, its class shall not
+ have any virtual base classes;
+- its *function-body* shall not enclose [[stmt.pre]]
   - a `goto` statement,
+  - an identifier label [[stmt.label]],
   - a definition of a variable of non-literal type or of static or
+    thread storage duration.
+  \[*Note 3*: A *function-body* that is `= delete` or `= default`
+  encloses none of the above. — *end note*]
 [*Example 2*:
 ``` cpp
 constexpr int square(int x)
 constexpr int first(int n) {
   static int value = n;         // error: variable has static storage duration
   return value;
 }
 constexpr int uninit() {
+ struct { int a; } s;
+  return s.a;                   // error: uninitialized read of s.a
 }
 constexpr int prev(int x)
   { return --x; }               // OK
 constexpr int g(int x, int n) { // OK
   int r = 1;
 }
 ```
 — *end example*]
+The definition of a constexpr constructor whose *function-body* is not
+`= delete` shall additionally satisfy the following requirements:
 - for a non-delegating constructor, every constructor selected to
   initialize non-static data members and base class subobjects shall be
   a constexpr constructor;
 - for a delegating constructor, the target constructor shall be a
   constexpr constructor.
 };
 ```
 — *end example*]
+The definition of a constexpr destructor whose *function-body* is not
+`= delete` shall additionally satisfy the following requirement:
+- for every subobject of class type or (possibly multi-dimensional)
+  array thereof, that class type shall have a constexpr destructor.
 For a constexpr function or constexpr constructor that is neither
 defaulted nor a template, 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]], or, for a
+constructor, an evaluated subexpression of the initialization
+full-expression of some constant-initialized object
+[[basic.start.static]], the program is ill-formed, no diagnostic
 required.
 [*Example 4*:
 ``` cpp
 — *end example*]
 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, that specialization is still
+a constexpr function, 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 when considered
+as a non-template function, the template is ill-formed, no diagnostic
+required.
+An invocation of a constexpr function in a given context produces the
+same result as an invocation of an equivalent non-constexpr function in
+the same context in all respects except that
+- an invocation of a constexpr function can appear in a constant
+ expression [[expr.const]] and
+- copy elision is not performed in a constant expression
+  [[class.copy.elision]].
+[*Note 4*: Declaring a function constexpr can change whether an
+expression is a constant expression. This can indirectly cause calls to
+`std::is_constant_evaluated` within an invocation of the function to
+produce a different value. — *end note*]
+The `constexpr` and `consteval` specifiers have no effect on the type of
+a constexpr function.
 [*Example 5*:
 ``` cpp
 constexpr int bar(int x, int y)         // OK
 ```
 — *end example*]
 A `constexpr` specifier used in an object declaration declares the
+object as const. Such an object shall have literal type and shall be
 initialized. In any `constexpr` variable declaration, the
+full-expression of the initialization shall be a constant expression
+[[expr.const]]. A `constexpr` variable shall have constant destruction.
 [*Example 6*:
 ``` cpp
 struct pixel {

Diff to HTML by rtfpessoa