Constant expressions

Defines an expression that can be evaluated at compile time.

Such expressions can be used as non-type template arguments, array sizes, and in other contexts that require constant expressions, e.g.

int n = 1;
std::array<int, n> a1; // error: n is not a constant expression
const int cn = 2;
std::array<int, cn> a2; // OK: cn is a constant expression

a function call to a constexpr function which is declared, but not defined
a function call to a constexpr function/constructor template instantiation where the instantiation fails to satisfy constexpr function/constructor requirements.
an expression that would exceed the implementation-defined limits

an expression whose evaluation leads to any form of core language undefined behavior (including signed integer overflow, division by zero, pointer arithmetic outside array bounds, etc). Whether standard library undefined behavior is detected is unspecified.

constexpr double d1 = 2.0/1.0; // OK
constexpr double d2 = 2.0/0.0; // Error: not defined
constexpr int n = std::numeric_limits<int>::max() + 1; // Error: overflow
int x, y, z[30];
constexpr auto e1 = &y - &x; // Error: undefined
constexpr auto e2 = &z[20] - &z[3]; // OK
constexpr std::bitset<2> a; 
constexpr bool b = a[2]; // UB, but unspecified if detected

(until C++17) a lambda expression
an lvalue-to-rvalue implicit conversion, unless the lvalue...
1. has integral or enumeration type and refers to a complete non-volatile const object, which is initialized with a constant expression
```
int main() {
    const std::size_t tabsize = 50;
    int tab[tabsize]; // OK: tabsize is a constant expression
 
    std::size_t n = 50;
    const std::size_t sz = n;
    int tab2[sz]; // error: sz is not a constant expression
                  // because sz is not initialized with a constant expression
}
```
2. is a non-volatile glvalue that refers to an element of a string literal
3. has literal type and refers to a non-volatile object defined with constexpr or a template parameter object (since C++20) or to its non-mutable subobject
4. has literal type and refers to a non-volatile object whose lifetime began within the evaluation of this expression
an lvalue-to-rvalue implicit conversion or modification applied to a non-active member of a union or its subobject (even if it shares a common initial sequence with the active member)
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 this expression
(since C++17) an assignment expression or invocation of an overloaded assignment operator that would change the active member of a union
an id-expression referring to a variable or a data member of reference type, unless it was initialized with a constant expression or its lifetime began within the evaluation of this expression
(since C++20) a checked contract whose predicate evaluates to false
conversion from cv void* to any pointer-to-object type
dynamic_cast
reinterpret_cast
pseudo-destructor call
(until C++14) an increment or a decrement operator

(since C++14) modification of an object, unless the object has non-volatile literal type and its lifetime began within the evaluation of the expression

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: x is not required to be initialized with 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 the expression h(1)

a typeid expression applied to a glvalue of polymorphic type
a new-expression or a delete-expression
(since C++20) a three-way comparison comparing pointers that do not point to the same complete object or to any subobject thereof
an equality or relational operator when the result is unspecified
(until C++14) an assignment or a compound assignment operator
a throw expression

inside a lambda-expression, a reference to this or to a variable defined outside that lambda, if that reference would be an odr-use

void g() {
  const int n=0;
  constexpr int j=*&n; // OK: outside of a lambda-expression
  [=]{ constexpr int i=n;  // OK: 'n' is not odr-used and not captured here.
       constexpr int j=*&n;// Ill-formed: '&n' would be an odr-use of 'n'.
     };
}

note that if the ODR-use takes place in a function call to a closure, it does not refer to this or to an enclosing variable, since it accesses a closure's data member instead

// OK: 'v' & 'm' are odr-used but do not occur in a constant-expression
// within the nested lambda
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)());

(since C++17)

Note: Just being a core constant expression does not have any direct semantic meaning: an expression has to be one of the following subsets to be used in certain contexts:

[edit] Integral constant expression

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. If an expression of class type is used where an integral constant expression is expected, the expression is contextually implicitly converted to an integral or unscoped enumeration type.

only integral constant expressions can be used as array bounds, the dimensions in new-expressions other than the first (until C++14), bit-field lengths, enumeration initializers when the underlying type is not fixed, null-pointer constants (until C++14), and alignments.

[edit] Converted constant expression

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:

constexpr user-defined conversions (so a class can be used where integral type is expected)
lvalue-to-rvalue conversions
integral promotions
non-narrowing integral conversions

array-to-pointer conversions
function-to-pointer conversions
function pointer conversions (pointer to noexcept function to pointer to function)
qualification conversions
null pointer conversions from std::nullptr_t
null member pointer conversions from std::nullptr_t

(since C++17)

And if any reference binding takes place, it is direct binding (not one that constructs a temporary object)

Only converted constant expressions can be used as case expressions, enumerator initializers when the underlying type is fixed, array bounds, the dimensions in new-expressions other than the first (since C++14), and as integral and enumeration (until C++17)non-type template arguments.

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. Such expressions can be used in noexcept specifications and static assert declarations.

[edit] Constant expression

A constant expression is either

a glvalue core constant expression that refers to

an object with static storage duration that is not a temporary, or
an object with static storage duration that is temporary, but whose value satisfies the constraints for prvalues below, or
a function

a prvalue core constant expression whose value satisfies the following constraints:

if the value is an object of class type, each non-static data member of reference type refers to an entity that satisfies the constraints for glvalues above
if the value is of pointer type, it holds

address of an object with static storage duration
address past the end of an object with static storage duration
address of a function
a null pointer value

if the value is an object of class or array type, each subobject satisfies these constraints for values

(since C++14)

A constant expression is a literal constant expression, a reference constant expression, or an address constant expression.

Literal constant expression is a prvalue core constant expression of non-pointer literal type (after conversions as required by context). A literal constant expression of array or class type requires that each subobject is initialized with a constant expression.

Reference constant expression is an lvalue core constant expression that designates an object with static storage duration or a function.

Address constant expression is a prvalue core constant expression (after conversions required by context) of type std::nullptr_t or of a pointer type, which points to an object with static storage duration, one past the end of an array with static storage duration, to a function, or is a null pointer.

(until C++14)

void test() {
    static const int a = std::random_device{}();
    constexpr const int& ra = a; // OK: a is a glvalue constant expression
    constexpr int ia = a; // Error: a is not a prvalue constant expression
 
    const int b = 42;
    constexpr const int& rb = b; // Error: b is not a glvalue constant expression
    constexpr int ib = b; // OK: b is a prvalue constant expression
}

[edit] Notes

Implementations are not permitted to declare library functions as constexpr unless the standard says the function is constexpr

copy elision is mandatory in constant expressions

(since C++14)

[edit] Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

DR	Applied to	Behavior as published	Correct behavior
CWG 2167	C++14	non-member references local to an evaluation were making the evaluation non-constexpr	non-member references allowed
CWG 1313	C++11	undefined behavior was permitted, and all pointer subtraction was prohibited	same-array pointer subtraction ok, UB prohibited
CWG 1952	C++11	standard library undefined behavior was required to be diagnosed	unspecified whether library UB is diagnosed

[edit] See also

Language
Headers
Freestanding and hosted implementations
Named requirements
Language support library
Concepts library (C++20)
Diagnostics library
Utilities library
Strings library
Containers library
Algorithms library
Iterators library
Numerics library
Input/output library
Localizations library
Regular expressions library (C++11)
Atomic operations library (C++11)
Thread support library (C++11)
Filesystem library (C++17)
Technical Specifications

General
value categories (lvalue, rvalue, xvalue)
order of evaluation (sequence points)
constant expressions
unevaluated expressions
primary expressions
lambda-expression(C++11)
Literals
integer literals
floating-point literals
boolean literals
character literals including escape sequences
string literals
null pointer literal(C++11)
user-defined literal(C++11)
Operators
Assignment operators: `a=b`, `a+=b`, `a-=b`, `a*=b`, `a/=b`, `a%=b`, `a&=b`, `a\|=b`, `a^=b`, `a<<=b`, `a>>=b`
Increment and decrement: `++a`, `--a`, `a++`, `a--`
Arithmetic operators: `+a`, `-a`, `a+b`, `a-b`, `a*b`, `a/b`, `a%b`, `~a`, `a&b`, `a\|b`, `a^b`, `a<<b`, `a>>b`
Logical operators: `a\|\|b`, `a&&b`, `!a`
Comparison operators: `a==b`, `a!=b`, `a<b`, `a>b`, `a<=b`, `a>=b`, `a<=>b`(C++20)
Member access operators: `a[b]`, `a`, `&a`, `a->b`, `a.b`, `a->b`, `a.*b`
Other operators: `a(...)`, `a,b`, `a?b:c`
Default comparisons(C++20)
Alternative representations of operators
Precedence and associativity
Fold expression(C++17)
new-expression
delete-expression
throw-expression
alignof
sizeof
sizeof...(C++11)
typeid
noexcept(C++11)
Operator overloading
Conversions
Implicit conversions
const_cast
static_cast
reinterpret_cast
dynamic_cast
Explicit conversions `(T)a`, `T(a)`
User-defined conversion

cppreference.com

Search

Namespaces

Variants

Views

Actions

Constant expressions

Contents

[edit] Core constant expressions