7 Expressions [expr]

7.7 Constant evaluation [expr.const]

7.7.3 Constant expressions [expr.const.const]

(1.1)
a glvalue core constant expression E for which
- (1.1.1)
  E refers to a non-immediate function,
- (1.1.2)
  E designates an object o, and if the complete object of o is of consteval-only type then so is E,
  [Example 1: struct Base { }; struct Derived : Base { std::meta::info r; }; consteval const Base& fn(const Derived& derived) { return derived; } constexpr Derived obj{.r=^^::}; // OK constexpr const Derived& d = obj; // OK constexpr const Base& b = fn(obj); // error: not a constant expression because Derived // is a consteval-only type but Base is not. — end example]
or
(1.2)
a prvalue core constant expression whose result object ([basic.lval]) satisfies the following constraints:
- (1.2.1)
  each constituent reference refers to an object or a non-immediate function,
- (1.2.2)
  no constituent value of scalar type is an indeterminate or erroneous value ([basic.indet]),
- (1.2.3)
  no constituent value of pointer type is a pointer to an immediate function or an invalid pointer value ([basic.compound]),
- (1.2.4)
  no constituent value of pointer-to-member type designates an immediate function, and
- (1.2.5)
  unless the value is of consteval-only type,
  - (1.2.5.1)
    no constituent value of pointer-to-member type points to a direct member of a consteval-only class type,
  - (1.2.5.2)
    no constituent value of pointer type points to or past an object whose complete object is of consteval-only type, and
  - (1.2.5.3)
    no constituent reference refers to an object whose complete object is of consteval-only type.

[Note 1:

A glvalue core constant expression that either refers to or points to an unspecified object is not a constant expression.

— end note]

[Example 2: consteval int f() { return 42; } consteval auto g() { return f; } consteval int h(int (*p)() = g()) { return p(); } constexpr int r = h(); // OK constexpr auto e = g(); // 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]

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 2:

Such expressions can be used as bit-field lengths ([class.bit]), as enumerator initializers if the underlying type is not fixed ([dcl.enum]), and as alignments .

— 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 ([conv]) to an integral or unscoped enumeration type and the selected conversion function shall be constexpr.

[Example 3: 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; // error: ambiguous conversion struct B { int n : a; }; // error: ambiguous conversion — end example]

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

(4.1)
user-defined conversions,
(4.2)
lvalue-to-rvalue conversions ([conv.lval]),
(4.3)
array-to-pointer conversions ([conv.array]),
(4.4)
function-to-pointer conversions ([conv.func]),
(4.5)
qualification conversions ([conv.qual]),
(4.6)
integral promotions ([conv.prom]),
(4.7)
integral conversions ([conv.integral]) other than narrowing conversions ([dcl.init.list]),
(4.8)
floating-point promotions ([conv.fpprom]),
(4.9)
floating-point conversions ([conv.double]) where the source value can be represented exactly in the destination type,
(4.10)
null pointer conversions ([conv.ptr]) from std::nullptr_t,
(4.11)
null member pointer conversions ([conv.mem]) from std::nullptr_t, and
(4.12)
function pointer conversions ([conv.fctptr]),

and where the reference binding (if any) binds directly.

[Note 3:

Such expressions can be used in new expressions ([expr.new]), as case expressions ([stmt.switch]), as enumerator initializers if the underlying type is fixed ([dcl.enum]), as array bounds ([dcl.array]), as constant template arguments ([temp.arg]), and as the constant expression of a splice-specifier ([basic.splice]).

— end note]

A contextually converted constant expression of type bool is an expression, contextually converted to bool ([conv]), where the converted expression is a constant expression and the conversion sequence contains only the conversions above.