Defines anexpression that can be evaluated at compile time.

Such expressions can be used as constant 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 expressionconstint cn=2;std::array<int, cn> a2;// OK: “cn” is a constant expression

[edit]Definition

When determining whether an expression is a constant expression,copy elision is assumed not to be performed.

The C++98 definition of constant expressions is entirely within the collapse box. The following description applies to C++11 and later C++ versions.

[edit]Literal type

The following types are collectively calledliteral types :

• possibly cv-qualifiedvoid
• scalar type
• reference type
• anarray of literal type
• possibly cv-qualified class type that satisfies all following conditions:

• It has atrivial destructor(until C++20)constexpr destructor(since C++20).
• All of its non-static non-variant data members and base classes are of non-volatile literal types.
• It is one of the following types:

• anaggregate union type that satisfies one of the following conditions:

• It has novariant member.
• It has at least one variant member of non-volatile literal type.

• a non-union aggregate type, and each of itsanonymous union members satisfies one of the following conditions:

• It has no variant member.
• It has at least one variant member of non-volatile literal type.

• a type with at least oneconstexpr constructor (template) that is not a copy or move constructor

Only objects of literal types can be created within a constant expression.

[edit]Core constant expression

Acore constant expression is any expression whose evaluationwould not evaluate any one of the following language constructs:

1. a function call expression that calls a function (or a constructor) that is not declaredconstexpr

   constexprint n=std::numeric_limits<int>::max();// OK: max() is constexprconstexprint m=std::time(nullptr);// Error: std::time() is not constexpr

2. a function call to a constexpr function which is declared, but not defined
3. a function call to a constexpr function/constructor template instantiation where the instantiation fails to satisfyconstexpr function/constructor requirements.
4. a function call to a constexpr virtual function, invoked on an object whose dynamic type is constexpr-unknown
5. an expression that would exceed the implementation-defined limits
6. an expression whose evaluation leads to any form of core languageundefined or erroneous(since C++26) behavior, except for any potential undefined behavior introduced bystandard attributes.

   constexprdouble d1=2.0/1.0;// OKconstexprdouble d2=2.0/0.0;// Error: not definedconstexprint n=std::numeric_limits<int>::max()+1;// Error: overflowint x, y, z[30];constexprauto e1=&y-&x;// Error: undefinedconstexprauto e2=&z[20]-&z[3];// OKconstexprstd::bitset<2> a;constexprbool b= a[2];// UB, but unspecified if detected

7. (until C++17) alambda expression
8. an lvalue-to-rvalueimplicit conversion unless applied to...
   1. a glvalue of type (possibly cv-qualified)std::nullptr_t
   2. a non-volatile literal-type glvalue that designates an object that isusable in constant expressions

      int main(){conststd::size_t tabsize=50;int tab[tabsize];// OK: tabsize is a constant expression// because tabsize is usable in constant expressions// because it has const-qualified integral type, and// its initializer is a constant initializer std::size_t n=50;conststd::size_t sz= n;int tab2[sz];// Error: sz is not a constant expression// because sz is not usable in constant expressions// because its initializer was not a constant initializer}

   3. a non-volatile literal-type glvalue that refers to a non-volatile object whose lifetime began within the evaluation of this expression
9. an lvalue-to-rvalueimplicit conversion or modification applied to a non-active member of aunion or its subobject (even if it shares a common initial sequence with the active member)
10. an lvalue-to-rvalue implicit conversion on an objectwhose value is indeterminate
11. an invocation of implicit copy/move constructor/assignment for a union whose active member is mutable (if any), with lifetime beginning outside the evaluation of this expression
12. (until C++20) an assignment expression that would change the active member of a union
13. conversion frompointer tovoid to a pointer-to-object typeT* unless the pointer holds a null pointer value or points to an object whose type issimilar toT(since C++26)
14. dynamic_castwhose operand is a glvalue that refers to an object whose dynamic type is constexpr-unknown(since C++20)
15. reinterpret_cast
16. (until C++20) pseudo-destructor call
17. (until C++14) an increment or a decrement operator
18. (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

    constexprint incr(int& n){return++n;} constexprint g(int k){constexprint x= incr(k);// Error: incr(k) is not a core constant// expression because lifetime of k// began outside the expression incr(k)return x;} constexprint h(int k){int x= incr(k);// OK: x is not required to be initialized// with a core constant expressionreturn x;} constexprint 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)

19. (since C++20) a destructor call or pseudo destructor call for an object whose lifetime did not begin within the evaluation of this expression
20. atypeid expression applied to a glvalue of polymorphic typeand that glvalue refers to an object whose dynamic type is constexpr-unknown(since C++20)
21. anew expression, unless one of the following conditions is satisfied:(since C++20)

    The selectedallocation function is a replaceable global allocation function and the allocated storage is deallocated within the evaluation of this expression.	(since C++20)
    The selected allocation function is a non-allocating form with an allocated typeT, and the placement argument satisfies all following conditions: It points to: an object whose type is similar toT, ifT is not an array type, or the first element of an object of a type similar toT, ifT is an array type. It points to storage whose duration began within the evaluation of this expression.	(since C++26)

22. adelete expression, unless it deallocates a region of storage allocated within the evaluation of this expression(since C++20)
23. (since C++20) Coroutines: anawait-expression or ayield-expression
24. (since C++20) athree-way comparison when the result is unspecified
25. an equality or relational operator whose result is unspecified
26. (until C++14) an assignment or a compound assignment operator
27. (until C++26) a throw expression
28. (since C++26) a construction of an exception object, unless the exception object and all of its implicit copies created by invocations ofstd::current_exception orstd::rethrow_exception are destroyed within the evaluation of this expression

    constexprvoid check(int i){if(i<0)throw i;} constexprbool is_ok(int i){try{        check(i);}catch(...){returnfalse;}returntrue;} constexprbool always_throw(){throw12;returntrue;} static_assert(is_ok(5));// OKstatic_assert(!is_ok(-1));// OK since C++26static_assert(always_throw());// Error: uncaught exception

29. anasm-declaration
30. an invocation of theva_arg macro
31. agoto statement
32. adynamic_cast ortypeid expressionornew expression(since C++26) that would throw an exceptionwhere no definition of the exception type is reachable(since C++26)
33. inside a lambda expression, a reference tothis or to a variable defined outside that lambda, if that reference would be an odr-use

    void g(){constint n=0; constexprint j=*&n;// OK: outside of a lambda-expression [=]{constexprint i= n;// OK: 'n' is not odr-used and not captured here.constexprint 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 tothis 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 lambdaauto 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)

[edit]Extra requirements

Even if an expressionE does not evaluate anything stated above, it is implementation-defined whetherE is a core constant expression if evaluatingE would result inruntime-undefined behavior.

Even if an expressionE does not evaluate anything stated above, it is unspecified whetherE is a core constant expression if evaluatingE would evaluate any of the following:

• An operation with undefined behavior in thestandard library.
• An invocation of theva_start macro.

For the purposes of determining whether an expression is a core constant expression, the evaluation of the body of a member function ofstd::allocator<T> is ignored ifT is a literal type.

For the purposes of determining whether an expression is a core constant expression, the evaluation of a call to a trivial copy/move constructor or copy/move assignment operator of aunion is considered to copy/move the active member of the union, if any.

During the evaluation of the expression as a core constant expression, all identifier expressions and uses of*this that refer to an object or reference whose lifetime began outside the evaluation of the expression are treated as referring to a specific instance of that object of that object or reference whose lifetime and that of all subobjects (including all union members) includes the entire constant evaluation.

• For such an object that is notusable in constant expressions(since C++20), the dynamic type of the object isconstexpr-unknown.
• For such a reference that is not usable constant expression(since C++20)s, the reference is treated as binding to an unspecified object of the referenced type whose lifetime and that of all subobjects includes the entire constant evaluation and whose dynamic type is constexpr-unknown.

[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 iscontextually implicitly converted to an integral or unscoped enumeration type.

[edit]Converted constant expression

Aconverted constant expression of typeT is an expressionimplicitly converted to typeT, where the converted expression is a constant expression, and the implicit conversion sequence contains only:

• constexpruser-defined conversions
• lvalue-to-rvalue conversions
• integral promotions
• non-narrowingintegral conversions
• floating-point promotions
• non-narrowingfloating-point conversions

And if anyreference binding takes place, it can only bedirect binding.

The following contexts require a converted constant expression:

• theconstant-expression ofcase labels
• enumerator initializers when the underlying type is fixed
• integral and enumeration(until C++17)constanttemplate arguments

Acontextually converted constant expression of typebool is an expression,contextually converted tobool, where the converted expression is a constant expression and the conversion sequence contains only the conversions above.

The following contexts require a contextually converted constant expression of typebool:

• noexcept specifications

[edit]Functions and variables needed for constant evaluation

Following expressions or conversions arepotentially constant evaluated:

• manifestly constant-evaluated expressions
• potentially-evaluated expressions
• immediate subexpressions of abraced-enclosed initializer list (constant evaluation may be necessary to determine whethera conversion is narrowing)
• address-of expressions that occur within atemplated entity (constant evaluation may be necessary to determine whether such an expression isvalue-dependent)
• subexpressions of one of the above that are not a subexpression of a nestedunevaluated operand

A function isneeded for constant evaluation if it is a constexpr function andnamed by an expression that is potentially constant evaluated.

A variable isneeded for constant evaluation if it is either a constexpr variable or is of non-volatile const-qualified integral type or of reference type and theidentifier expression that denotes it is potentially constant evaluated.

Definition of a defaulted function and instantiation of afunction template specializationorvariable template specialization(since C++14) are triggered if the functionor variable(since C++14) is needed for constant evaluation.

[edit]Constant subexpression

Aconstant subexpression is an expression whose evaluation assubexpression of an expressione would not prevente from being acore constant expression, wheree is not any of the following expressions:

• throw expression

• assignment expression
• comma expression

[edit]Notes

[edit]Example

[edit]Defect reports

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

[edit]See also

• In other languages

• Español
• 日本語
• Русский
• 中文