Constant expressions - cppreference.com (original) (raw)

Defines an expression 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 expression const int cn = 2; std::array<int, cn> a2; // OK: “cn” is a constant expression

Contents

• 1 Definition
  • 1.1 Integral constant expression (C++98)
  • 1.2 Other constant expression categories
• 2 Literal type
• 3 Core constant expression
  • 3.1 Extra requirements
• 4 Integral constant expression
• 5 Converted constant expression
• 6 Constituent entities
• 7 Constexpr-representable entities
• 8 Constant-initialized entities
• 9 Usable in constant expressions
• 10 Manifestly constant-evaluated expressions
• 11 Functions and variables needed for constant evaluation
• 12 Constant subexpression
• 13 Notes
• 14 Example
• 15 Defect reports
• 16 See also

[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 called literal types :

• possibly cv-qualified void

• scalar type

• reference type

• an array of literal type

• possibly cv-qualified class type that satisfies all following conditions:

• It has a trivial 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:

• an aggregate union type that satisfies one of the following conditions:

• It has no variant member.

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

• a non-union aggregate type, and each of its anonymous 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 one constexpr 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

A core constant expression is any expression whose evaluation would not evaluate any one of the following language constructs:

1. a function call expression that calls a function (or a constructor) that is not declared constexpr
   constexpr int n = std::numeric_limits::max(); // OK: max() is constexpr
   constexpr int 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 satisfy constexpr 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 language undefined or erroneous(since C++26) behavior, except for any potential undefined behavior introduced by standard attributes.
   constexpr double d1 = 2.0 / 1.0; // OK
   constexpr double d2 = 2.0 / 0.0; // Error: not defined
   constexpr int n = std::numeric_limits::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
7. (until C++17) a lambda expression
8. an lvalue-to-rvalue implicit 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 is usable in constant expressions
      int main()
      {
      const std::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;
      const std::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-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)
10. an lvalue-to-rvalue implicit conversion on an object whose 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 from pointer to void to a pointer-to-object type T* unless the pointer holds a null pointer value or points to an object whose type is similar to T(since C++26)
14. dynamic_cast whose 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
    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) 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. a typeid expression applied to a glvalue of polymorphic type and that glvalue refers to an object whose dynamic type is constexpr-unknown(since C++20) 21. a new expression, unless one of the following conditions is satisfied:(since C++20)

if (i < 0)  
    throw i;  

}
 
constexpr bool is_ok(int i)
{
try {
check(i);
} catch (...) {
return false;
}
return true;
}
 
constexpr bool always_throw()
{
throw 12;
return true;
}
 
static_assert(is_ok(5)); // OK
static_assert(!is_ok(-1)); // OK since C++26
static_assert(always_throw()); // Error: uncaught exception 29. an asm-declaration 30. an invocation of the va_arg macro 31. a goto statement 32. a dynamic_cast or typeid expression or new expression(since C++26) that would throw an exception where no definition of the exception type is reachable(since C++26) 33. 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'.
};
}

[edit]

Even if an expression E does not evaluate anything stated above, it is implementation-defined whether E is a core constant expression if evaluating E would result in runtime-undefined behavior.

Even if an expression E does not evaluate anything stated above, it is unspecified whether E is a core constant expression if evaluating E would evaluate any of the following:

• An operation with undefined behavior in the standard library.
• An invocation of the va_start macro.

For the purposes of determining whether an expression is a core constant expression, the evaluation of the body of a member function of std::allocator<T> is ignored if T 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 a union 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 not usable in constant expressions(since C++20), the dynamic type of the object is constexpr-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 is contextually implicitly converted to an integral or unscoped enumeration type.

[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
• lvalue-to-rvalue conversions
• integral promotions
• non-narrowing integral conversions
• floating-point promotions
• non-narrowing floating-point conversions

And if any reference binding takes place, it can only be direct binding.

The following contexts require a converted constant expression:

• the constant-expression of case labels
• enumerator initializers when the underlying type is fixed
• integral and enumeration (until C++17)constant 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.

The following contexts require a contextually converted constant expression of type bool:

• noexcept specifications

[edit] Functions and variables needed for constant evaluation

Following expressions or conversions are potentially constant evaluated:

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

A function is needed for constant evaluation if it is a constexpr function and named by an expression that is potentially constant evaluated.

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

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

[edit] Constant subexpression

A constant subexpression is an expression whose evaluation as subexpression of an expression e would not prevent e from being a core constant expression, where e 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