Working Draft Programming Languages — C++
https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2025/n5008.pdf

7.7 Constant expressions [expr.const]

1 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 (11.9.6) is not performed, are called constant expressions.
[Note 1: Constant expressions can be evaluated during translation. —end note]
constant-expression: conditional-expression
2 The constituent values of an object o are
—
if o has scalar type, the value of o;
—
otherwise, the constituent values of any direct subobjects of o other than inactive union members.
The constituent references of an object o are
—
any direct members of o that have reference type, and
—
the constituent references of any direct subobjects of o other than inactive union members.
3 The constituent values and constituent references of a variable x are defined as follows:
(3.1) —
If x declares an object, the constituent values and references of that object are constituent values and references of x.
(3.2) —
If x declares a reference, that reference is a constituent reference of x.
For any constituent reference r of a variable x, if r is bound to a temporary object or subobject thereof whose lifetime is extended to that of r, the constituent values and references of that temporary object are also constituent values and references of x, recursively.
4 An object o is constexpr-referenceable from a point P if
(4.1) (4.2) (4.2.1) (4.2.2) —
o has static storage duration, or
—
o has automatic storage duration, and, letting v denote
—
the variable corresponding to o’s complete object or
—
the variable to whose lifetime that of o is extended,
the smallest scope enclosing v and the smallest scope enclosing P that are neither
(4.2.3) block scopes nor
—
(4.2.4) —
function parameter scopes associated with a requirement-parameter-list
are the same function parameter scope.
[Example 1:
struct A {
int m;
const int& r;
};
void f() {
static int sx;
thread_local int tx; // tx is never constexpr-referenceable
int ax;
A aa = {1, 2};
static A sa = {3, 4};
// The objects sx, ax, and aa.m, sa.m, and the temporaries to which aa.r and sa.r are bound, are constexpr-
referenceable.
auto lambda = [] {
int ay;
// The objects sx, sa.m, and ay (but not ax or aa), and the
// temporary to which sa.r is bound, are constexpr-referenceable.
};
}
—end example]
5 An object or reference x is constexpr-representable at a point P if, for each constituent value of x that points to or past an object o, and for each constituent reference of x that refers to an object o, o is constexpr-referenceable from P.
6 A variable v is constant-initializable if
(6.1) (6.2) (6.3) —
the full-expression of its initialization is a constant expression when interpreted as a constant-expression with all contract assertions using the ignore evaluation semantic (6.10.2),
[Note 2: Within this evaluation, std::is_constant_evaluated() (21.3.11) returns true. —end note]
[Note 3: The initialization, when evaluated, can still evaluate contract assertions with other evaluation semantics, resulting in a diagnostic or ill-formed program if a contract violation occurs. —end note]
—
immediately after the initializing declaration of v, the object or reference x declared by v is constexpr-representable, and
—
if x has static or thread storage duration, x is constexpr-representable at the nearest point whose immediate scope is a namespace scope that follows the initializing declaration of v.
7 A constant-initializable variable is constant-initialized if either it has an initializer or its type is const-default-constructible (9.5.1).
[Example 2:
void f() {
int ax = 0; thread_local int tx = 0; static int sx; static int& rss = sx; static int& rst = tx; static int& rsa = ax; thread_local int& rts = sx; thread_local int& rtt = tx; thread_local int& rta = ax; int& ras = sx; int& rat = tx; int& raa = ax; // ax is constant-initialized
// tx is constant-initialized
// sx is not constant-initialized
// rss is constant-initialized
// rst is not constant-initialized
// rsa is not constant-initialized
// rts is constant-initialized
// rtt is not constant-initialized
// rta is not constant-initialized
// ras is constant-initialized
// rat is not constant-initialized
// raa is constant-initialized
}
—end example]
8 A variable is potentially-constant if it is constexpr or it has reference or non-volatile const-qualified integral or enumeration type.
9 A constant-initialized potentially-constant variable V is usable in constant expressions at a point P if V’s initializing declaration D is reachable from P and
(9.1) V is constexpr,
—
(9.2) —
V is not initialized to a TU-local value, or
(9.3) —
P is in the same translation unit as D.
(9.4) (9.5) (9.6) (9.7) (9.8) (9.9) An object or reference is potentially usable in constant expressions at point P if it is
—
the object or reference declared by a variable that is usable in constant expressions at P,
—
a temporary object of non-volatile const-qualified literal type whose lifetime is extended (6.7.7) to that of a variable that is usable in constant expressions at P,
—
a template parameter object (13.2),
—
a string literal object (5.13.5),
—
a non-mutable subobject of any of the above, or
—
a reference member of any of the above.
An object or reference is usable in constant expressions at point P if it is an object or reference that is potentially usable in constant expressions at P and is constexpr-representable at P.
[Example 3:
struct A {
int* const & r;
};
void f(int x) {
constexpr A a = {&x};
static_assert(a.r == &x); // OK
[&] {
static_assert(a.r != nullptr); }();
// error: a.r is not usable in constant expressions at this point
}
—end example]
10 An expression E is a core constant expression unless the evaluation of E, following the rules of the abstract machine (6.9.1), would evaluate one of the following:
—
(10.1) this (7.5.3), except
(10.1.1) (10.1.2) —
in a constexpr function (9.2.6) that is being evaluated as part of E or
—
when appearing as the postfix-expression of an implicit or explicit class member access expression (7.6.1.5);
(10.2) —
a control flow that passes through a declaration of a block variable (6.4.3) with static (6.7.6.2) or thread (6.7.6.3) storage duration, unless that variable is usable in constant expressions;
[Example 4:
constexpr char test() {
static const int x = 5;
static constexpr char c[] = "Hello World";
return *(c + x);
(10.3) (10.4) (10.5) (10.6) (10.7) (10.8) (10.9) (10.9.1) (10.9.2) (10.9.3) (10.10) (10.11) (10.12) —
—
}
static_assert(' ' == test());
—end example]
an invocation of a non-constexpr function;67
an invocation of an undefined constexpr function;
an invocation of an instantiated constexpr function that is not constexpr-suitable;
an invocation of a virtual function (11.7.3) for an object whose dynamic type is constexpr-unknown;
an expression that would exceed the implementation-defined limits (see Annex B);
an operation that would have undefined or erroneous behavior as specified in Clause 4 through Clause 15;68
an lvalue-to-rvalue conversion (7.3.2) unless it is applied to
—
a glvalue of type cvstd::nullptr_t,
—
a non-volatile glvalue that refers to an object that is usable in constant expressions, or
—
a non-volatile glvalue of literal type that refers to a non-volatile object whose lifetime began within the evaluation of E;
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;
an lvalue-to-rvalue conversion that is applied to an object with an indeterminate value (6.7.5);
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;

Overload resolution (12.2) is applied as usual.
This includes, for example, signed integer overflow (7.1), certain pointer arithmetic (7.6.6), division by zero (7.6.5), or
certain shift operations (7.6.7).
(10.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 (6.3, 7.5.6);
[Example 5:
void g() {
const int n = 0;
[=] {
constexpr int i = n; constexpr int j = &n; // OK, n is not odr-used here
// error: &n would be an odr-use of n
};
}
—end example]
[Note 4: 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 variable with automatic storage duration due to the transformation (7.5.6.3) of the id-expression into an access of the corresponding data member.
[Example 6:
auto monad = [](auto v) { return [=] { return v; }; };
auto bind = [](auto m) {
return [=](auto fvm) { return fvm(m()); };
};
// OK to capture objects with automatic storage duration created during constant expression evaluation.
static_assert(bind(monad(2))(monad)() == monad(2)());
—end example]
—end note]
(10.14) —
a conversion from a prvalue P of type “pointer to cv void” to a type “cv1 pointer to T”, where T is not cv2 void, unless P is a null pointer value or points to an object whose type is similar to T;
—
(10.15) a reinterpret_cast (7.6.1.10);
(10.16) —
a modification of an object (7.6.19, 7.6.1.6, 7.6.2.3) 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;
(10.17) —
an invocation of a destructor (11.4.7) or a function call whose postfix-expression names a pseudo-destructor (7.6.1.3), in either case for an object whose lifetime did not begin within the evaluation ofE;
(10.18) (10.18.1) (10.18.2) (10.18.2.1) (10.18.2.2) (10.19) —
a new-expression (7.6.2.8), unless either
—
the selected allocation function is a replaceable global allocation function (17.6.3.2, 17.6.3.3) and the allocated storage is deallocated within the evaluation of E, or
—
the selected allocation function is a non-allocating form (17.6.3.4) with an allocated type T, where
—
the placement argument to the new-expression points to an object whose type is similar to T (7.3.6) or, if T is an array type, to the first element of an object of a type similar to T, and
—
the placement argument points to storage whose duration began within the evaluation of E;
a delete-expression (7.6.2.9), unless it deallocates a region of storage allocated within the evaluation of E;
(10.20) —
a call to an instance of std::allocator::allocate (20.2.10.2), unless the allocated storage is deallocated within the evaluation of E;
(10.21) —
a call to an instance of std::allocator::deallocate (20.2.10.2), unless it deallocates a region of storage allocated within the evaluation of E;
(10.22) —
a construction of an exception object, unless the exception object and all of its implicit copies created by invocations of std::current_exception or std::rethrow_exception (17.9.7) are destroyed within the evaluation of E;
—
(10.23) an await-expression (7.6.2.4);
—
(10.24) a yield-expression (7.6.17);
(10.25) —
a three-way comparison (7.6.8), relational (7.6.9), or equality (7.6.10) operator where the result is unspecified;
(10.26) —
a dynamic_cast (7.6.1.7) or typeid (7.6.1.8) expression on a glvalue that refers to an object whose dynamic type is constexpr-unknown;
(10.27) —
a dynamic_cast (7.6.1.7) expression, typeid (7.6.1.8) expression, or new-expression (7.6.2.8) that would throw an exception where no definition of the exception type is reachable;
—
(10.28) an asm-declaration (9.11);
(10.29) (10.30) —
an invocation of the va_arg macro (17.14.2);
—
a non-constant library call (3.35); or
—
(10.31) a goto statement (8.7.6).
[Note 5: A goto statement introduced by equivalence (Clause 8) is not in scope. For example, a while statement (8.6.2) can be executed during constant evaluation. —end note]
11 It is implementation-defined whether E is a core constant expression if E satisfies the constraints of a core constant expression, but evaluation of E has runtime-undefined behavior.
12 It is unspecified whether E is a core constant expression if E satisfies the constraints of a core constant expression, but evaluation of E would evaluate
(12.1) (12.2) —
an operation that has undefined behavior as specified in Clause 16 through Clause 33 or
—
an invocation of the va_start macro (17.14.2).
13 [Example 7:
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); return x;
// OK, incr(k) is not required to be a core constant expression
}
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)
14 —end example]
For the purposes of determining whether an expression E is a core constant expression, the evaluation of the body of a member function of std::allocator as defined in 20.2.10.2, where T is a literal type, is ignored.
15 16 (16.1) (16.2) 17 For the purposes of determining whether E 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.
[Note 6: The copy/move of the active member is trivial. —end note]
For the purposes of determining whether E is a core constant expression, the evaluation of an id-expression that names a structured binding v (9.7) has the following semantics:
—
If v is an lvalue referring to the object bound to an invented reference r, the behavior is as if r were nominated.
—
Otherwise, if v names an array element or class member, the behavior is that of evaluating e[i] or e.m, respectively, where e is the name of the variable initialized from the initializer of the structured
binding declaration, and i is the index of the element referred to by v or m is the name of the member referred to by v, respectively.
[Example 8:
#include
struct S {
mutable int m;
constexpr S(int m): m(m) {}
virtual int g() const;
};
void f(std::tuple t) {
auto [r] = t;
static_assert(r.g() >= 0); constexpr auto [m] = S(1);
static_assert(m == 1); // error: dynamic type is constexpr-unknown
// error: lvalue-to-rvalue conversion on mutable
// subobject e.m, where e is a constexpr object of type S
using A = int[2];
constexpr auto [v0, v1] = A{2, 3};
static_assert(v0 + v1 == 5); // OK, equivalent to e[0] + e[1] where e is a constexpr array
}
—end example]
During the evaluation of an expression E as a core constant expression, all id-expressions and uses of this that refer to an object or reference whose lifetime did not begin with the evaluation of E are treated as referring to a specific instance 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, the dynamic type of the object is constexpr-unknown. For such a reference that is not usable in constant expressions, 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.
[Example 9:
template
constexpr size_t array_size(T (&)[N]) {
return N;
}
void use_array(int const (&gold_medal_mel)[2]) {
constexpr auto gold = array_size(gold_medal_mel); // OK
}
constexpr auto olympic_mile() {
const int ledecky = 1500;
return []{ return ledecky; };
}
static_assert(olympic_mile()() == 1500); // OK
struct Swim {
constexpr int phelps() { return 28; }
virtual constexpr int lochte() { return 12; }
int coughlin = 12;
};
}
constexpr int how_many(Swim& swam) {
Swim p = &swam;
return (p + 1 - 1)->phelps();
void splash(Swim& swam) {
static_assert(swam.phelps() == 28); // OK
static_assert((&swam)->phelps() == 28); // OK
Swim pswam = &swam;
static_assert(pswam->phelps() == 28); static_assert(how_many(swam) == 28); // OK
static_assert(Swim().lochte() == 12); // OK
static_assert(swam.lochte() == 12); static_assert(swam.coughlin == 12); // error: lvalue-to-rvalue conversion on a pointer
// not usable in constant expressions
// error: invoking virtual function on reference
// with constexpr-unknown dynamic type
// error: lvalue-to-rvalue conversion on an object
// not usable in constant expressions
18 (18.1) (18.2) 19 20 }
extern Swim dc;
extern Swim& trident;
constexpr auto& sandeno = typeid(dc); constexpr auto& gallagher = typeid(trident); // OK, can only be typeid(Swim)
// error: constexpr-unknown dynamic type
—end example]
An object a is said to have constant destruction if
—
it is not of class type nor (possibly multidimensional) array thereof, or
—
it is of class type or (possibly multidimensional) array thereof, that class type has a constexpr destructor, and for a hypothetical expression E whose only effect is to destroy a, E would be a core constant expression if the lifetime of a and its non-mutable subobjects (but not its mutable subobjects) were considered to start within E.
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 7: Such expressions can be used as bit-field lengths (11.4.10), as enumerator initializers if the underlying type is not fixed (9.8.1), and as alignments (9.13.2). —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 (7.3) to an integral or unscoped enumeration type and the selected conversion function shall be constexpr.
[Example 10:
struct A {
constexpr A(int i) : val(i) { }
constexpr operator int() const { return val; }
constexpr operator long() const { return 42; }
private:
int val;
};
constexpr A a = alignof(int);
alignas(a) int n; struct B { int n : a; }; —end example]
// error: ambiguous conversion
// error: ambiguous conversion
21 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
(21.1) user-defined conversions,
—
—
(21.2) lvalue-to-rvalue conversions (7.3.2),
—
(21.3) array-to-pointer conversions (7.3.3),
—
(21.4) function-to-pointer conversions (7.3.4),
—
(21.5) qualification conversions (7.3.6),
—
(21.6) integral promotions (7.3.7),
(21.7) —
integral conversions (7.3.9) other than narrowing conversions (9.5.5),
—
(21.8) floating-point promotions (7.3.8),
(21.9) —
floating-point conversions (7.3.10) where the source value can be represented exactly in the destination
type,
(21.10) (21.11) —
null pointer conversions (7.3.12) from std::nullptr_t,
—
null member pointer conversions (7.3.13) from std::nullptr_t, and
—
(21.12) function pointer conversions (7.3.14),
and where the reference binding (if any) binds directly.
[Note 8: Such expressions can be used in new expressions (7.6.2.8), as case expressions (8.5.3), as enumerator initializers if the underlying type is fixed (9.8.1), as array bounds (9.3.4.5), and as constant template arguments (13.4). —end
note]
A contextually converted constant expression of type bool is an expression, contextually converted to bool (7.3), where the converted expression is a constant expression and the conversion sequence contains only the conversions above.
22 A constant expression is either a glvalue core constant expression that refers to an object or a non-immediate function, or a prvalue core constant expression whose result object (7.2.1) satisfies the following constraints:
(22.1) (22.2) (22.3) —
each constituent reference refers to an object or a non-immediate function,
—
no constituent value of scalar type is an indeterminate or erroneous value (6.7.5),
—
no constituent value of pointer type is a pointer to an immediate function or an invalid pointer value (6.8.4), and
(22.4) —
no constituent value of pointer-to-member type designates an immediate function.
[Note 9: A glvalue core constant expression that either refers to or points to an unspecified object is not a constant expression. —end note]
[Example 11:
consteval int f() { return 42; }
consteval auto g() { return f; }
consteval int h(int (*p)() = g()) { return p(); }
constexpr int r = h(); constexpr auto e = g(); // OK
// error: a pointer to an immediate function is
// not a permitted result of a constant expression
struct S {
int x;
constexpr S() {}
};
int i() {
constexpr S s; }
// error: s.x has erroneous value
—end example]
23 Recommended practice: Implementations should provide consistent results of floating-point evaluations, irrespective of whether the evaluation is performed during translation or during program execution.
24 (24.1) (24.2) (24.3) 25 (25.1) (25.2) (26.1) (26.2) (26.3) 27 (27.1) (27.2) [Note 10: 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.
[Example 12:
bool f() {
char array[1 + int(1 + 0.2 - 0.1 - 0.1)]; int size = 1 + int(1 + 0.2 - 0.1 - 0.1); // Must be evaluated during translation
// 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 or conversion is in an immediate function context if it is potentially evaluated and either:
—
its innermost enclosing non-block scope is a function parameter scope of an immediate function,
—
it is a subexpression of a manifestly constant-evaluated expression or conversion, or
—
its enclosing statement is enclosed (8.1) by the compound-statement of a consteval if statement (8.5.2).
An invocation is an immediate invocation if it is a potentially-evaluated explicit or implicit invocation of an immediate function and is not in an immediate function context. An aggregate initialization is an immediate invocation if it evaluates a default member initializer that has a subexpression that is an immediate-escalating
expression.
An expression or conversion is immediate-escalating if it is not initially in an immediate function context and it is either
—
—
a potentially-evaluated id-expression that denotes an immediate function that is not a subexpression of an immediate invocation, or
an immediate invocation that is not a constant expression and is not a subexpression of an immediate invocation.
26 An immediate-escalating function is
—
the call operator of a lambda that is not declared with the consteval specifier,
—
a defaulted special member function that is not declared with the consteval specifier, or
—
a function that results from the instantiation of a templated entity defined with the constexpr specifier.
An immediate-escalating expression shall appear only in an immediate-escalating function.
An immediate function is a function or constructor that is
—
declared with the consteval specifier, or
—
an immediate-escalating function F whose function body contains an immediate-escalating expression E such that E ’s innermost enclosing non-block scope is F ’s function parameter scope.
[Note 11: Default member initializers used to initialize a base or member subobject (11.9.3) are considered to be part of the function body (9.6.1). —end note]
[Example 13:
consteval int id(int i) { return i; }
constexpr char id(char c) { return c; }
template
constexpr int f(T t) {
return t + id(t);
}
auto a = &f; auto b = &f; static_assert(f(3) == 6); // OK
// OK, f is not an immediate function
// error: f is an immediate function
template
constexpr int g(T t) { return t + id(42); // g is not an immediate function
// because id(42) is already a constant
}
template
constexpr bool is_not(T t, F f) {
return not f(t);
}
consteval bool is_even(int i) { return i % 2 == 0; }
static_assert(is_not(5, is_even)); // OK
int x = 0;
template
constexpr T h(T t = id(x)) { // h is not an immediate function
// id(x) is not evaluated when parsing the default argument (9.3.4.7, 13.9.2)
return t;
}
template
constexpr T hh() { return h(); // hh is an immediate function because of the invocation
// of the immediate function id in the default argument of h
}
int i = hh(); // error: hh() is an immediate-escalating expression
// outside of an immediate-escalating function
struct A {
int x;
int y = id(x);
};
template
constexpr int k(int) { return A(42).y; // k is not an immediate function because A(42) is a
// constant expression and thus not immediate-escalating
}
constexpr int l(int c) pre(c >= 2) {
return (c % 2 == 0) ? c / 0 : c;
}
const int i0 = l(0); const int i1 = l(1); const int i2 = l(2); const int i3 = l(3); // dynamic initialization; contract violation or undefined behavior
// static initialization; value of 1 or contract violation at compile time
// dynamic initialization; undefined behavior
// static initialization; value of 3
—end example]
28 (28.2) (28.4) An expression or conversion is manifestly constant-evaluated if it is: (28.1) a constant-expression, or
—
—
the condition of a constexpr if statement (8.5.2), or (28.3) an immediate invocation, or
—
—
the result of substitution into an atomic constraint expression to determine whether it is satisfied (13.5.2.3), or (28.5) —
the initializer of a variable that is usable in constant expressions or has constant initialization (6.9.3.2).69
Testing this condition can involve a trial evaluation of its initializer, with evaluations of contract assertions using the ignore
evaluation semantic (6.10.2), as described above.
[Example 14:
template struct X {};
Xstd::is_constant_evaluated() x; // type X
int y;
const int a = std::is_constant_evaluated() ? y : 1; double z[a]; const int b = std::is_constant_evaluated() ? 2 : y; int c = y + (std::is_constant_evaluated() ? 2 : y); // dynamic initialization to 1
// error: a is not usable
// in constant expressions
// static initialization to 2
// dynamic initialization to y+y
constexpr int f() {
const int n = std::is_constant_evaluated() ? 13 : 17; // n is 13
int m = std::is_constant_evaluated() ? 13 : 17; char arr[n] = {}; // char[13]
return m + sizeof(arr);
// m can be 13 or 17 (see below)
}
int p = f(); int q = p + f(); // m is 13; initialized to 26
// m is 17 for this call; initialized to 56
—end example]
[Note 12: Except for a static_assert-message, a manifestly constant-evaluated expression is evaluated even in an unevaluated operand (7.2.3). —end note]
29 An expression or conversion is potentially constant evaluated if it is:
—
(29.1) a manifestly constant-evaluated expression,
—
(29.2) a potentially-evaluated expression (6.3),
(29.3) —
an immediate subexpression of a braced-init-list, 70
(29.4) —
an expression of the form & cast-expression that occurs within a templated entity,71 or
(29.5) —
a potentially-evaluated subexpression (6.9.1) of one of the above.
A function or variable is needed for constant evaluation if it is:
(29.6) (29.7) —
a constexpr function that is named by an expression (6.3) that is potentially constant evaluated, or
—
a potentially-constant variable named by a potentially constant evaluated expression.
In some cases, constant evaluation is needed to determine whether a narrowing conversion is performed (9.5.5).
In some cases, constant evaluation is needed to determine whether such an expression is value-dependent (13.8.3.4).