Namespaces
Variants
Views
Actions

Constant expressions

From cppreference.com
< cpp‎ | language

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

Contents

[edit] Core constant expressions

A core constant expression is any expression that does not have any one of the following in any subexpression (except that arguments of &&, ||, and ?: that aren't evaluated are not considered)

1) A function call expression that calls a function (or a constructor) that is not declared constexpr
constexpr int n = std::numeric_limits<int>::max(); // OK, max() is constexpr
constexpr int m = std::time(NULL); // Error: std::time() is not constexpr
2) A function call to a constexpr function which is declared, but not defined, if the function call itself is not made inside the body of a constexpr function.
3) A function call to a constexpr function with arguments that do not produce a constant expression when substituted
constexpr const int* addr(const int& ir) { return &ir; }
static const int x = 5;
constexpr const int* xp = addr(x); // OK
constexpr const int* tp = addr(5); // error: &5 is not a constant expression
4) A function call to a constexpr function with arguments that do not produce constant expressions in member-initializer lists that are called from this function
int x;
struct A {
    constexpr A(bool b) : m(b?42:x) { }
    int m;
};
constexpr int v = A(true).m; // OK
constexpr int w = A(false).m; // error: non-const x
5) A function call to a recursive constexpr function that would exceed compile-time recursion depth limit (implementation-defined)
6) The this pointer except if used for class member access inside a non-static member function.
7) An expression whose result is not mathematically defined or is out of range for its type.
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
(until C++14)
7) An expression whose evaluation leads to any form of undefined behavior (including signed integer overflow, division by zero, pointer arithmetic outside array bounds, etc)
(since C++14)
9) An lvalue-to-rvalue implicit conversion applied to a non-active member of a union or its subobject
10) Any other lvalue-to-rvalue implicit conversion, unless the lvalue...
a) has integral or enumeration type, is non-volatile const, and is initialized with a constant expression, or an array of such (including a string literal)
b) has literal type and refers to a non-volatile object defined with constexpr or to its non-mutable subobject
c) has literal type and refers to a non-volatile temporary, initialized with a constant expression
11) a reference to a variable unless it was initialized with a constant expression or is a non-static data member of a temporary object whose lifetime begain within this expression
12) conversion from cv void* to any pointer-to-object type
(since C++14)
15) pseudo-destructor call
16) an increment or a decrement operator
17) a typeid expression applied to a glvalue of polymorphic type
18) a new-expression or a delete-expression
19) a subtraction operator between two pointers
20) an equality or relational operator when the result is unspecified
21) an assignment or a compount assignment operator
22) a throw expression

[edit] 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.
only integral constant expressions can be used as bit-field lengths, enumeration initializers when the underlying type is not fixed, null-pointer constants, and alignments
  • Converted constant expression is an expression implicitly converted to prvalye of type T, where the converted expression is a core constant expression. If the literal constant expression has class type, it is contextually implicitly converted to the expected integral or unscoped enumeration type with a constexpr user-defined conversion function.
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, and as integral and enumeration non-type template arguments
  • 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.

[edit] Notes

Implementations are not permitted to declare library functions as constexpr unless the standard says the function is constexpr (since C++14)

[edit] See also