7 Expressions [expr]

7.7 Constant expressions [expr.const]

Certain contexts require expressions that satisfy additional requirements as detailed in this subclause; other contexts have different semantics depending on whether or not an expression satisfies these requirements.

Expressions that satisfy these requirements, assuming that copy elision is performed, are called constant expressions.

[ Note

Constant expressions can be evaluated during translation.

— end note

]

constant-expression:
	conditional-expression

An expression e is a core constant expression unless the evaluation of e, following the rules of the abstract machine, would evaluate one of the following expressions:

(2.1)
this, except in a constexpr function or a constexpr constructor that is being evaluated as part of e;
(2.2)
an invocation of a function other than a constexpr constructor for a literal class, a constexpr function, or an implicit invocation of a trivial destructor ([class.dtor])
[ Note
:
Overload resolution is applied as usual
— end note
]
;
(2.3)
an invocation of an undefined constexpr function or an undefined constexpr constructor;
(2.4)
an invocation of an instantiated constexpr function or constexpr constructor that fails to satisfy the requirements for a constexpr function or constexpr constructor;
(2.5)
an expression that would exceed the implementation-defined limits;
(2.6)
an operation that would have undefined behavior as specified in [intro] through [cpp] of this document
[ Note
:
including, for example, signed integer overflow ([expr.prop]), certain pointer arithmetic ([expr.add]), division by zero, or certain shift operations
— end note
]
;
(2.7)
an lvalue-to-rvalue conversion unless it is applied to
- (2.7.1)
  a non-volatile glvalue of integral or enumeration type that refers to a complete non-volatile const object with a preceding initialization, initialized with a constant expression, or
- (2.7.2)
  a non-volatile glvalue that refers to a subobject of a string literal, or
- (2.7.3)
  a non-volatile glvalue that refers to a non-volatile object defined with constexpr or a template parameter object ([temp.param]), or that refers to a non-mutable subobject of such an object, or
- (2.7.4)
  a non-volatile glvalue of literal type that refers to a non-volatile object whose lifetime began within the evaluation of e;
(2.8)
an lvalue-to-rvalue conversion that is applied to a glvalue that refers to a non-active member of a union or a subobject thereof;
(2.9)
an invocation of an implicitly-defined copy/move constructor or copy/move assignment operator for a union whose active member (if any) is mutable, unless the lifetime of the union object began within the evaluation of e;
(2.10)
an assignment expression ([expr.ass]) or invocation of an assignment operator ([class.copy.assign]) that would change the active member of a union;
(2.11)
an id-expression that refers to a variable or data member of reference type unless the reference has a preceding initialization and either
- (2.11.1)
  it is initialized with a constant expression or
- (2.11.2)
  its lifetime began within the evaluation of e;
(2.12)
a checked contract ([dcl.attr.contract]) whose predicate evaluates to false;
(2.13)
in a lambda-expression, a reference to this or to a variable with automatic storage duration defined outside that lambda-expression, where the reference would be an odr-use;
[ Example
:
```
void g() {
  const int n = 0;
  [=] {
    constexpr int i = n;   // OK, n is not odr-used here
    constexpr int j = *&n; // ill-formed, &n would be an odr-use of n
  };
}
```
— end example
]
[ Note
:
If the odr-use occurs in an invocation of a function call operator of a closure type, it no longer refers to this or to an enclosing automatic variable due to the transformation ([expr.prim.lambda.capture]) of the id-expression into an access of the corresponding data member.
[ Example
:
auto monad = [](auto v) { return [=] { return v; }; }; auto bind = [](auto m) { return [=](auto fvm) { return fvm(m()); }; }; // OK to have captures to automatic objects created during constant expression evaluation. static_assert(bind(monad(2))(monad)() == monad(2)());
— end example
]
— end note
]
(2.14)
a conversion from type cv void* to a pointer-to-object type;
(2.15)
a dynamic cast;
(2.16)
a reinterpret_cast;
(2.17)
a pseudo-destructor call;
(2.18)
modification of an object ([expr.ass], [expr.post.incr], [expr.pre.incr]) unless it is applied to a non-volatile lvalue of literal type that refers to a non-volatile object whose lifetime began within the evaluation of e;
(2.19)
a typeid expression whose operand is a glvalue of a polymorphic class type;
(2.20)
a new-expression;
(2.21)
a delete-expression;
(2.22)
a three-way comparison ([expr.spaceship]) comparing pointers that do not point to the same complete object or to any subobject thereof;
(2.23)
a relational ([expr.rel]) or equality ([expr.eq]) operator where the result is unspecified;
(2.24)
a throw-expression; or
(2.25)
an invocation of the va_arg macro ([cstdarg.syn]).

If e satisfies the constraints of a core constant expression, but evaluation of e would evaluate an operation that has undefined behavior as specified in [library] through [thread] of this document, or an invocation of the va_start macro ([cstdarg.syn]), it is unspecified whether e is a core constant expression.

[ Example

int x;                              // not constant
struct A {
  constexpr A(bool b) : m(b?42:x) { }
  int m;
};
constexpr int v = A(true).m;        // OK: constructor call initializes m with the value 42

constexpr int w = A(false).m;       // error: initializer for m is x, which is non-constant

constexpr int f1(int k) {
  constexpr int x = k;              // error: x is not initialized by a constant expression
                                    // because lifetime of k began outside the initializer of x
  return x;
}
constexpr int f2(int k) {
  int x = k;                        // OK: not required to be a constant expression
                                    // because x is not constexpr
  return x;
}

constexpr int incr(int &n) {
  return ++n;
}
constexpr int g(int k) {
  constexpr int x = incr(k);        // error: incr(k) is not a core constant expression
                                    // because lifetime of k began outside the expression incr(k)
  return x;
}
constexpr int h(int k) {
  int x = incr(k);                  // OK: incr(k) is not required to be a core constant expression
  return x;
}
constexpr int y = h(1);             // OK: initializes y with the value 2
                                    // h(1) is a core constant expression because
                                    // the lifetime of k begins inside h(1)

— end example

]

An integral constant expression is an expression of integral or unscoped enumeration type, implicitly converted to a prvalue, where the converted expression is a core constant expression.

[ Note

Such expressions may be used as bit-field lengths, as enumerator initializers if the underlying type is not fixed ([dcl.enum]), and as alignments .

— end note

]

If an expression of literal class type is used in a context where an integral constant expression is required, then that expression is contextually implicitly converted ([conv]) to an integral or unscoped enumeration type and the selected conversion function shall be constexpr.

[ Example

struct A {
  constexpr A(int i) : val(i) { }
  constexpr operator int() const { return val; }
  constexpr operator long() const { return 42; }
private:
  int val;
};
template<int> struct X { };
constexpr A a = alignof(int);
alignas(a) int n;              // error: ambiguous conversion
struct B { int n : a; };       // error: ambiguous conversion

— end example

]

A converted constant expression of type T is an expression, implicitly converted to type T, where the converted expression is a constant expression and the implicit conversion sequence contains only

(5.1)
user-defined conversions,
(5.2)
lvalue-to-rvalue conversions,
(5.3)
array-to-pointer conversions,
(5.4)
function-to-pointer conversions,
(5.5)
qualification conversions,
(5.6)
integral promotions,
(5.7)
integral conversions other than narrowing conversions,
(5.8)
null pointer conversions from std::nullptr_t,
(5.9)
null member pointer conversions from std::nullptr_t, and
(5.10)
function pointer conversions,

and where the reference binding (if any) binds directly.

[ Note

Such expressions may be used in new expressions, as case expressions, as enumerator initializers if the underlying type is fixed, as array bounds, and as non-type template arguments .

— end note

]

A contextually converted constant expression of type bool is an expression, contextually converted to bool, where the converted expression is a constant expression and the conversion sequence contains only the conversions above.

A constant expression is either a glvalue core constant expression that refers to an entity that is a permitted result of a constant expression (as defined below), or a prvalue core constant expression whose value satisfies the following constraints:

(6.1)
if the value is an object of class type, each non-static data member of reference type refers to an entity that is a permitted result of a constant expression,
(6.2)
if the value is of pointer type, it contains the address of an object with static storage duration, the address past the end of such an object ([expr.add]), the address of a function, or a null pointer value, and
(6.3)
if the value is an object of class or array type, each subobject satisfies these constraints for the value.

An entity is a permitted result of a constant expression if it is an object with static storage duration that is either not a temporary object or is a temporary object whose value satisfies the above constraints, or it is a function.

[ Note

Since this document imposes no restrictions on the accuracy of floating-point operations, it is unspecified whether the evaluation of a floating-point expression during translation yields the same result as the evaluation of the same expression (or the same operations on the same values) during program execution.89

[ Example

bool f() {
    char array[1 + int(1 + 0.2 - 0.1 - 0.1)];  // Must be evaluated during translation
    int size = 1 + int(1 + 0.2 - 0.1 - 0.1);   // May be evaluated at runtime
    return sizeof(array) == size;
}

It is unspecified whether the value of f() will be true or false.

— end example

]

— end note

]

An expression is potentially constant evaluated if it is:

(8.1)
a potentially-evaluated expression ([basic.def.odr]),
(8.2)
a constraint-expression, including one formed from the constraint-logical-or-expression of a requires-clause,
(8.3)
an immediate subexpression of a braced-init-list,90
(8.4)
an expression of the form & cast-expression that occurs within a templated entity,91 or
(8.5)
a subexpression of one of the above that is not a subexpression of a nested unevaluated operand.

A function or variable is needed for constant evaluation if it is:

(8.6)
a constexpr function that is named by an expression ([basic.def.odr]) that is potentially constant evaluated, or
(8.7)
a variable whose name appears as a potentially constant evaluated expression that is either a constexpr variable or is of non-volatile const-qualified integral type or of reference type.

89)

Nonetheless, implementations should provide consistent results, irrespective of whether the evaluation was performed during translation and/or during program execution.

90)

Constant evaluation may be necessary to determine whether a narrowing conversion is performed ([dcl.init.list]).

91)

Constant evaluation may be necessary to determine whether such an expression is value-dependent ([temp.dep.constexpr]).