[expr.const] - C++17 → C++20

Files changed (1) hide show

tmp/tmpctanqfvt/{from.md → to.md} +430 -207

tmp/tmpctanqfvt/{from.md → to.md} RENAMED Viewed

@@ -2,127 +2,163 @@
 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 is performed, are called *constant
-expressions*.
 [*Note 1*: Constant expressions can be evaluated during
 translation. — *end note*]
 ``` bnf
 constant-expression:
     conditional-expression
 ```
-An expression `e` is a *core constant expression* unless the evaluation
-of `e`, following the rules of the abstract machine (
-[[intro.execution]]), would evaluate one of the following expressions:
-- `this` ([[expr.prim.this]]), except in a constexpr function or a
- constexpr constructor that is being evaluated as part of `e`;
-- an invocation of a function other than a constexpr constructor for a
- literal class, a constexpr function, or an implicit invocation of a
- trivial destructor ([[class.dtor]]) \[*Note 2*: Overload resolution (
- [[over.match]]) is applied as usual — *end note*] ;
-- an invocation of an undefined constexpr function or an undefined
-  constexpr constructor;
-- an invocation of an instantiated constexpr function or constexpr
-  constructor that fails to satisfy the requirements for a constexpr
-  function or constexpr constructor ([[dcl.constexpr]]);
 - an expression that would exceed the implementation-defined limits (see
- Annex  [[implimits]]);
 - an operation that would have undefined behavior as specified in
- Clauses  [[intro]] through  [[cpp]] of this International Standard
- \[*Note 3*: including, for example, signed integer overflow (Clause
-  [[expr]]), certain pointer arithmetic ([[expr.add]]), division by
- zero ([[expr.mul]]), or certain shift operations (
- [[expr.shift]]) — *end note*] ;
-- an lvalue-to-rvalue conversion ([[conv.lval]]) unless it is applied
-  to
-  - a non-volatile glvalue of integral or enumeration type that refers
-    to a complete non-volatile const object with a preceding
-    initialization, initialized with a constant expression, or
-  - a non-volatile glvalue that refers to a subobject of a string
-    literal ([[lex.string]]), or
-  - a non-volatile glvalue that refers to a non-volatile object defined
-    with `constexpr`, or that refers to a non-mutable subobject of such
-    an object, 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 ([[conv.lval]]) that is applied to a
   glvalue that refers to a non-active member of a union or a subobject
   thereof;
 - 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`;
-- an assignment expression ([[expr.ass]]) or invocation of an
-  assignment operator ([[class.copy]]) that would change the active
-  member of a union;
 - an *id-expression* that refers to a variable or data member of
   reference type unless the reference has a preceding initialization and
   either
-  - it is initialized with a constant expression or
-  - its lifetime began within the evaluation of `e`;
 - 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 ([[basic.def.odr]],
   [[expr.prim.lambda]]);
   \[*Example 1*:
   ``` cpp
   void g() {
     const int n = 0;
     [=] {
-      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
     };
   }
   ```
   — *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
-  automatic variable due to the transformation (
-  [[expr.prim.lambda.capture]]) of the *id-expression* into an access of
   the corresponding data member.
   \[*Example 2*:
   ``` cpp
   auto 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)());
   ```
   — *end example*]
   — *end note*]
 - a conversion from type cv `void*` to a pointer-to-object type;
-- a dynamic cast ([[expr.dynamic.cast]]);
-- a `reinterpret_cast` ([[expr.reinterpret.cast]]);
-- a pseudo-destructor call ([[expr.pseudo]]);
-- modification of an object ([[expr.ass]], [[expr.post.incr]],
   [[expr.pre.incr]]) 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`;
-- a typeid expression ([[expr.typeid]]) whose operand is a glvalue of a
- polymorphic class type;
-- a *new-expression* ([[expr.new]]);
-- a *delete-expression* ([[expr.delete]]);
-- a relational ([[expr.rel]]) or equality ([[expr.eq]]) operator where
-  the result is unspecified; or
-- a *throw-expression* ([[expr.throw]]).
-If `e` satisfies the constraints of a core constant expression, but
-evaluation of `e` would evaluate an operation that has undefined
-behavior as specified in Clauses  [[library]] through  [[thread]] of
-this International Standard, it is unspecified whether `e` is a core
-constant expression.
 [*Example 3*:
 ``` cpp
 int x;                              // not constant
@@ -162,47 +198,101 @@ constexpr int y = h(1);             // OK: initializes y with the value 2
                                     // the lifetime of k begins inside h(1)
 ```
 — *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 5*: Such expressions may be used as bit-field lengths (
-[[class.bit]]), as enumerator initializers if the underlying type is not
-fixed ([[dcl.enum]]), and as alignments (
-[[dcl.align]]). — *end note*]
 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
 - user-defined conversions,
-- lvalue-to-rvalue conversions ([[conv.lval]]),
-- array-to-pointer conversions ([[conv.array]]),
-- function-to-pointer conversions ([[conv.func]]),
-- qualification conversions ([[conv.qual]]),
-- integral promotions ([[conv.prom]]),
-- integral conversions ([[conv.integral]]) other than narrowing
-  conversions ([[dcl.init.list]]),
-- null pointer conversions ([[conv.ptr]]) from `std::nullptr_t`,
-- null member pointer conversions ([[conv.mem]]) from `std::nullptr_t`,
   and
-- function pointer conversions ([[conv.fctptr]]),
 and where the reference binding (if any) binds directly.
-[*Note 6*: Such expressions may 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]]), and as non-type template arguments (
-[[temp.arg]]). — *end note*]
 A *contextually converted constant expression of type `bool`* is an
-expression, contextually converted to `bool` (Clause [[conv]]), where
-the converted expression is a constant expression and the conversion
 sequence contains only the conversions above.
 A *constant expression* is either a glvalue core constant expression
 that refers to an entity that is a permitted result of a constant
 expression (as defined below), or a prvalue core constant expression
@@ -211,29 +301,44 @@ whose value satisfies the following constraints:
 - if the value is an object of class type, each non-static data member
   of reference type refers to an entity that is a permitted result of a
   constant expression,
 - if the value is of pointer type, it contains the address of an object
   with static storage duration, the address past the end of such an
-  object ([[expr.add]]), the address of a function, or a null pointer
-  value, and
 - if the value is an object of class or array type, each subobject
   satisfies these constraints for the value.
 An entity is a *permitted result of a constant expression* if it is an
-object with static storage duration that is either not a temporary
 object or is a temporary object whose value satisfies the above
-constraints, or it is a function.
-[*Note 7*:
-Since this International Standard 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.[^28]
-[*Example 4*:
 ``` cpp
 bool f() {
     char array[1 + int(1 + 0.2 - 0.1 - 0.1)];   // Must be evaluated during translation
     int size = 1 + int(1 + 0.2 - 0.1 - 0.1);    // May be evaluated at runtime
@@ -245,48 +350,88 @@ It is unspecified whether the value of `f()` will be `true` or `false`.
 — *end example*]
 — *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 (Clause  [[conv]]) to an integral or
-unscoped enumeration type and the selected conversion function shall be
-`constexpr`.
-[*Example 5*:
   ``` cpp
-struct A {
- constexpr A(int i) : val(i) { }
- constexpr operator int() const { return val; }
- constexpr operator long() const { return 43; }
-private:
-  int val;
-};
-template<int> struct X { };
-constexpr A a = 42;
-X<a> x;             // OK: unique conversion to int
-int ary[a]; // error: ambiguous conversion
   ```
   — *end example*]
 <!-- Link reference definitions -->
-[bad.alloc]: language.md#bad.alloc
-[bad.cast]: language.md#bad.cast
-[bad.typeid]: language.md#bad.typeid
 [basic.align]: basic.md#basic.align
 [basic.compound]: basic.md#basic.compound
 [basic.def.odr]: basic.md#basic.def.odr
 [basic.fundamental]: basic.md#basic.fundamental
 [basic.life]: basic.md#basic.life
 [basic.lookup]: basic.md#basic.lookup
 [basic.lookup.argdep]: basic.md#basic.lookup.argdep
 [basic.lookup.classref]: basic.md#basic.lookup.classref
 [basic.lookup.unqual]: basic.md#basic.lookup.unqual
-[basic.lval]: basic.md#basic.lval
 [basic.namespace]: dcl.md#basic.namespace
 [basic.scope.block]: basic.md#basic.scope.block
 [basic.scope.class]: basic.md#basic.scope.class
 [basic.start.main]: basic.md#basic.start.main
 [basic.stc.dynamic]: basic.md#basic.stc.dynamic
@@ -297,87 +442,111 @@ int ary[a];         // error: ambiguous conversion
 [basic.types]: basic.md#basic.types
 [class]: class.md#class
 [class.abstract]: class.md#class.abstract
 [class.access]: class.md#class.access
 [class.access.base]: class.md#class.access.base
-[class.base.init]: special.md#class.base.init
 [class.bit]: class.md#class.bit
-[class.cdtor]: special.md#class.cdtor
-[class.conv]: special.md#class.conv
-[class.conv.fct]: special.md#class.conv.fct
-[class.copy]: special.md#class.copy
-[class.ctor]: special.md#class.ctor
 [class.derived]: class.md#class.derived
-[class.dtor]: special.md#class.dtor
-[class.free]: special.md#class.free
 [class.friend]: class.md#class.friend
-[class.init]: special.md#class.init
 [class.mem]: class.md#class.mem
 [class.member.lookup]: class.md#class.member.lookup
 [class.mfct]: class.md#class.mfct
 [class.mfct.non-static]: class.md#class.mfct.non-static
-[class.name]: class.md#class.name
 [class.qual]: basic.md#class.qual
 [class.static]: class.md#class.static
-[class.temporary]: special.md#class.temporary
 [class.this]: class.md#class.this
 [class.union]: class.md#class.union
 [class.virtual]: class.md#class.virtual
-[conv]: conv.md#conv
-[conv.array]: conv.md#conv.array
-[conv.bool]: conv.md#conv.bool
-[conv.fctptr]: conv.md#conv.fctptr
-[conv.fpint]: conv.md#conv.fpint
-[conv.fpprom]: conv.md#conv.fpprom
-[conv.func]: conv.md#conv.func
-[conv.integral]: conv.md#conv.integral
-[conv.lval]: conv.md#conv.lval
-[conv.mem]: conv.md#conv.mem
-[conv.prom]: conv.md#conv.prom
-[conv.ptr]: conv.md#conv.ptr
-[conv.qual]: conv.md#conv.qual
-[conv.rval]: conv.md#conv.rval
 [cpp]: cpp.md#cpp
-[cstddef.syn]: language.md#cstddef.syn
 [dcl.align]: dcl.md#dcl.align
 [dcl.array]: dcl.md#dcl.array
 [dcl.constexpr]: dcl.md#dcl.constexpr
 [dcl.dcl]: dcl.md#dcl.dcl
 [dcl.enum]: dcl.md#dcl.enum
 [dcl.fct]: dcl.md#dcl.fct
 [dcl.fct.def]: dcl.md#dcl.fct.def
 [dcl.fct.def.general]: dcl.md#dcl.fct.def.general
 [dcl.fct.default]: dcl.md#dcl.fct.default
 [dcl.init]: dcl.md#dcl.init
 [dcl.init.aggr]: dcl.md#dcl.init.aggr
 [dcl.init.list]: dcl.md#dcl.init.list
 [dcl.init.ref]: dcl.md#dcl.init.ref
 [dcl.link]: dcl.md#dcl.link
 [dcl.name]: dcl.md#dcl.name
 [dcl.ref]: dcl.md#dcl.ref
 [dcl.spec.auto]: dcl.md#dcl.spec.auto
 [dcl.stc]: dcl.md#dcl.stc
 [dcl.struct.bind]: dcl.md#dcl.struct.bind
 [dcl.type]: dcl.md#dcl.type
 [dcl.type.cv]: dcl.md#dcl.type.cv
 [dcl.type.simple]: dcl.md#dcl.type.simple
 [except]: except.md#except
 [except.handle]: except.md#except.handle
 [except.spec]: except.md#except.spec
 [except.terminate]: except.md#except.terminate
 [except.throw]: except.md#except.throw
 [expr]: #expr
 [expr.add]: #expr.add
 [expr.alignof]: #expr.alignof
 [expr.ass]: #expr.ass
 [expr.bit.and]: #expr.bit.and
 [expr.call]: #expr.call
 [expr.cast]: #expr.cast
 [expr.comma]: #expr.comma
 [expr.cond]: #expr.cond
 [expr.const]: #expr.const
 [expr.const.cast]: #expr.const.cast
 [expr.delete]: #expr.delete
 [expr.dynamic.cast]: #expr.dynamic.cast
 [expr.eq]: #expr.eq
 [expr.log.and]: #expr.log.and
 [expr.log.or]: #expr.log.or
@@ -385,51 +554,64 @@ int ary[a];         // error: ambiguous conversion
 [expr.mul]: #expr.mul
 [expr.new]: #expr.new
 [expr.or]: #expr.or
 [expr.post]: #expr.post
 [expr.post.incr]: #expr.post.incr
 [expr.pre.incr]: #expr.pre.incr
 [expr.prim]: #expr.prim
 [expr.prim.fold]: #expr.prim.fold
 [expr.prim.id]: #expr.prim.id
 [expr.prim.id.qual]: #expr.prim.id.qual
 [expr.prim.id.unqual]: #expr.prim.id.unqual
 [expr.prim.lambda]: #expr.prim.lambda
 [expr.prim.lambda.capture]: #expr.prim.lambda.capture
 [expr.prim.lambda.closure]: #expr.prim.lambda.closure
 [expr.prim.literal]: #expr.prim.literal
 [expr.prim.paren]: #expr.prim.paren
 [expr.prim.this]: #expr.prim.this
-[expr.pseudo]: #expr.pseudo
 [expr.ref]: #expr.ref
 [expr.reinterpret.cast]: #expr.reinterpret.cast
 [expr.rel]: #expr.rel
 [expr.shift]: #expr.shift
 [expr.sizeof]: #expr.sizeof
 [expr.static.cast]: #expr.static.cast
 [expr.sub]: #expr.sub
 [expr.throw]: #expr.throw
 [expr.type.conv]: #expr.type.conv
 [expr.typeid]: #expr.typeid
 [expr.unary]: #expr.unary
 [expr.unary.noexcept]: #expr.unary.noexcept
 [expr.unary.op]: #expr.unary.op
 [expr.xor]: #expr.xor
 [function.objects]: utilities.md#function.objects
 [implimits]: limits.md#implimits
 [intro]: intro.md#intro
-[intro.execution]: intro.md#intro.execution
-[intro.memory]: intro.md#intro.memory
-[intro.object]: intro.md#intro.object
 [lex.literal]: lex.md#lex.literal
 [lex.string]: lex.md#lex.string
 [library]: library.md#library
 [namespace.qual]: basic.md#namespace.qual
-[new.badlength]: language.md#new.badlength
-[new.delete.array]: language.md#new.delete.array
-[new.delete.placement]: language.md#new.delete.placement
-[new.delete.single]: language.md#new.delete.single
 [over]: over.md#over
 [over.ass]: over.md#over.ass
 [over.best.ics]: over.md#over.best.ics
 [over.built]: over.md#over.built
 [over.call]: over.md#over.call
@@ -440,121 +622,162 @@ int ary[a];         // error: ambiguous conversion
 [over.match.oper]: over.md#over.match.oper
 [over.match.viable]: over.md#over.match.viable
 [over.oper]: over.md#over.oper
 [over.over]: over.md#over.over
 [replacement.functions]: library.md#replacement.functions
 [stmt.return]: stmt.md#stmt.return
 [stmt.switch]: stmt.md#stmt.switch
-[support.runtime]: language.md#support.runtime
-[support.types]: language.md#support.types
-[support.types.layout]: language.md#support.types.layout
 [temp.arg]: temp.md#temp.arg
 [temp.expl.spec]: temp.md#temp.expl.spec
 [temp.explicit]: temp.md#temp.explicit
-[temp.mem]: temp.md#temp.mem
 [temp.names]: temp.md#temp.names
 [temp.res]: temp.md#temp.res
 [temp.variadic]: temp.md#temp.variadic
 [thread]: thread.md#thread
-[type.info]: language.md#type.info
 [^1]: The precedence of operators is not directly specified, but it can
     be derived from the syntax.
-[^2]: As a consequence, operands of type `bool`, `char16_t`, `char32_t`,
- `wchar_t`, or an enumerated type are converted to some integral
-    type.
 [^3]: The cast and assignment operators must still perform their
-    specific conversions as described in  [[expr.cast]],
-    [[expr.static.cast]] and  [[expr.ass]].
-[^4]: This also applies when the object expression is an implicit
     `(*this)` ([[class.mfct.non-static]]).
-[^5]: This is true even if the subscript operator is used in the
     following common idiom: `&x[0]`.
-[^6]: If the class member access expression is evaluated, the
     subexpression evaluation happens even if the result is unnecessary
     to determine the value of the entire postfix expression, for example
     if the *id-expression* denotes a static member.
-[^7]: Note that `(*(E1))` is an lvalue.
-[^8]: The most derived object ([[intro.object]]) pointed or referred to
     by `v` can contain other `B` objects as base classes, but these are
     ignored.
-[^9]: The recommended name for such a class is `extended_type_info`.
-[^10]: If `p` is an expression of pointer type, then `*p`, `(*p)`,
     `*(p)`, `((*p))`, `*((p))`, and so on all meet this requirement.
-[^11]: Function types (including those used in pointer to member
-    function types) are never cv-qualified; see  [[dcl.fct]].
-[^12]: The types may have different cv-qualifiers, subject to the
     overall restriction that a `reinterpret_cast` cannot cast away
     constness.
-[^13]: `T1` and `T2` may have different cv-qualifiers, subject to the
     overall restriction that a `reinterpret_cast` cannot cast away
     constness.
-[^14]: This is sometimes referred to as a *type pun*.
-[^15]: `const_cast`
     is not limited to conversions that cast away a const-qualifier.
-[^16]: `sizeof(bool)` is not required to be `1`.
-[^17]: The actual size of a base class subobject may be less than the
-    result of applying `sizeof` to the subobject, due to virtual base
-    classes and less strict padding requirements on base class
-    subobjects.
-[^18]: If the conversion function returns a signed integer type, the
     second standard conversion converts to the unsigned type
     `std::size_t` and thus thwarts any attempt to detect a negative
     value afterwards.
-[^19]: This may include evaluating a *new-initializer* and/or calling a
     constructor.
-[^20]: A lambda expression with a *lambda-introducer* that consists of
-    empty square brackets can follow the `delete` keyword if the lambda
-    expression is enclosed in parentheses.
-[^21]: This implies that an object cannot be deleted using a pointer of
     type `void*` because `void` is not an object type.
-[^22]: For nonzero-length arrays, this is the same as a pointer to the
     first element of the array created by that *new-expression*.
     Zero-length arrays do not have a first element.
-[^23]: If the static type of the object to be deleted is complete and is
-    different from the dynamic type, and the destructor is not virtual,
-    the size might be incorrect, but that case is already undefined, as
-    stated above.
-[^24]: This is often called truncation towards zero.
-[^25]: An object that is not an array element is considered to belong to
-    a single-element array for this purpose; see  [[expr.unary.op]]. A
-    pointer past the last element of an array `x` of n elements is
-    considered to be equivalent to a pointer to a hypothetical element
- x[n] for this purpose; see  [[basic.compound]].
-[^26]: An object that is not an array element is considered to belong to
-    a single-element array for this purpose; see  [[expr.unary.op]]. A
- pointer past the last element of an array `x` of n elements is
-    considered to be equivalent to a pointer to a hypothetical element
-    x[n] for this purpose; see  [[basic.compound]].
-[^27]: An object that is not an array element is considered to belong to
- a single-element array for this purpose; see  [[expr.unary.op]].
-[^28]: Nonetheless, implementations are encouraged to provide consistent
-    results, irrespective of whether the evaluation was performed during
     translation and/or during program execution.

 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 [[class.copy.elision]] is not performed, are
+called *constant expressions*.
 [*Note 1*: Constant expressions can be evaluated during
 translation. — *end note*]
 ``` bnf
 constant-expression:
     conditional-expression
 ```
+A variable or temporary object `o` is *constant-initialized* if
+- either it has an initializer or its default-initialization results in
+  some initialization being performed, and
+- the full-expression of its initialization is a constant expression
+ when interpreted as a *constant-expression*, except that if `o` is an
+  object, that full-expression may also invoke constexpr constructors
+ for `o` and its subobjects even if those objects are of non-literal
+  class types. \[*Note 2*: Such a class may have a non-trivial
+ destructor. Within this evaluation, `std::is_constant_evaluated()`
+  [[meta.const.eval]] returns `true`. — *end note*]
+A variable is *potentially-constant* if it is constexpr or it has
+reference or const-qualified integral or enumeration type.
+A constant-initialized potentially-constant variable is *usable in
+constant expressions* at a point P if its initializing declaration D is
+reachable from P and
+- it is constexpr,
+- it is not initialized to a TU-local value, or
+- P is in the same translation unit as D.
+An object or reference is *usable in constant expressions* if it is
+- a variable that is usable in constant expressions, or
+- a template parameter object [[temp.param]], or
+- a string literal object [[lex.string]], or
+- a temporary object of non-volatile const-qualified literal type whose
+  lifetime is extended [[class.temporary]] to that of a variable that is
+  usable in constant expressions, or
+- a non-mutable subobject or reference member of any of the above.
+An expression E is a *core constant expression* unless the evaluation of
+E, following the rules of the abstract machine [[intro.execution]],
+would evaluate one of the following:
+- `this` [[expr.prim.this]], except in a constexpr function
+  [[dcl.constexpr]] that is being evaluated as part of E;
+- an invocation of a non-constexpr function \[*Note 3*: Overload
+  resolution [[over.match]] is applied as usual. — *end note*] ;
+- an invocation of an undefined constexpr function;
+- an invocation of an instantiated constexpr function that fails to
+  satisfy the requirements for a constexpr function;
+- an invocation of a virtual function [[class.virtual]] for an object
+  unless
+  - the object is usable in constant expressions or
+  - its lifetime began within the evaluation of E;
 - an expression that would exceed the implementation-defined limits (see
+  [[implimits]]);
 - an operation that would have undefined behavior as specified in
+  [[intro]] through [[cpp]] of this document \[*Note 4*: including, for
+  example, signed integer overflow [[expr.prop]], certain pointer
+ arithmetic [[expr.add]], division by zero [[expr.mul]], or certain
+ shift operations [[expr.shift]] — *end note*] ;
+- an lvalue-to-rvalue conversion [[conv.lval]] unless it is applied to
+ - 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 [[conv.lval]] 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 [[basic.indet]];
 - 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;
 - an *id-expression* that refers to a variable or data member of
   reference type unless the reference has a preceding initialization and
   either
+  - it is usable in constant expressions or
+  - its lifetime began within the evaluation of E;
 - 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 ([[basic.def.odr]],
   [[expr.prim.lambda]]);
   \[*Example 1*:
   ``` cpp
   void g() {
     const int n = 0;
     [=] {
+      constexpr int i = n; // OK, n is not odr-used here
+      constexpr int j = *&n; // error: &n would be an odr-use of n
     };
   }
   ```
   — *end example*]
+  \[*Note 5*:
   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
+  automatic variable due to the transformation
+  [[expr.prim.lambda.capture]] of the *id-expression* into an access of
   the corresponding data member.
   \[*Example 2*:
   ``` cpp
   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*]
 - a conversion from type cv `void*` to a pointer-to-object type;
+- a `reinterpret_cast` [[expr.reinterpret.cast]];
+- a modification of an object ([[expr.ass]], [[expr.post.incr]],
   [[expr.pre.incr]]) 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;
+- a *new-expression* [[expr.new]], unless the selected allocation
+ function is a replaceable global allocation function (
+ [[new.delete.single]], [[new.delete.array]]) and the allocated storage
+  is deallocated within the evaluation of E;
+- a *delete-expression* [[expr.delete]], unless it deallocates a region
+ of storage allocated within the evaluation of E;
+- a call to an instance of `std::allocator<T>::allocate`
+  [[allocator.members]], unless the allocated storage is deallocated
+  within the evaluation of E;
+- a call to an instance of `std::allocator<T>::deallocate`
+  [[allocator.members]], unless it deallocates a region of storage
+  allocated within the evaluation of E;
+- an *await-expression* [[expr.await]];
+- a *yield-expression* [[expr.yield]];
+- a three-way comparison [[expr.spaceship]], relational [[expr.rel]], or
+  equality [[expr.eq]] operator where the result is unspecified;
+- a *throw-expression* [[expr.throw]] or a dynamic cast
+  [[expr.dynamic.cast]] or `typeid` [[expr.typeid]] expression that
+  would throw an exception;
+- an *asm-declaration* [[dcl.asm]]; or
+- an invocation of the `va_arg` macro [[cstdarg.syn]].
+If E satisfies the constraints of a core constant expression, but
+evaluation of E would evaluate an operation that has undefined behavior
+as specified in [[library]] through [[thread]] of this document, or an
+invocation of the `va_start` macro [[cstdarg.syn]], it is unspecified
+whether E is a core constant expression.
 [*Example 3*:
 ``` cpp
 int x;                              // not constant
                                     // the lifetime of k begins inside h(1)
 ```
 — *end example*]
+For the purposes of determining whether an expression E is a core
+constant expression, the evaluation of a call to a member function of
+`std::allocator<T>` as defined in [[allocator.members]], where `T` is a
+literal type, does not disqualify E from being a core constant
+expression, even if the actual evaluation of such a call would otherwise
+fail the requirements for a core constant expression. Similarly, the
+evaluation of a call to `std::destroy_at`, `std::ranges::destroy_at`,
+`std::construct_at`, or `std::ranges::construct_at` does not disqualify
+E from being a core constant expression unless:
+- for a call to `std::construct_at` or `std::ranges::construct_at`, the
+  first argument, of type `T*`, does not point to storage allocated with
+  `std::allocator<T>` or to an object whose lifetime began within the
+  evaluation of E, or the evaluation of the underlying constructor call
+  disqualifies E from being a core constant expression, or
+- for a call to `std::destroy_at` or `std::ranges::destroy_at`, the
+  first argument, of type `T*`, does not point to storage allocated with
+  `std::allocator<T>` or to an object whose lifetime began within the
+  evaluation of E, or the evaluation of the underlying destructor call
+  disqualifies E from being a core constant expression.
+An object `a` is said to have *constant destruction* if:
+- it is not of class type nor (possibly multi-dimensional) array
+  thereof, or
+- it is of class type or (possibly multi-dimensional) 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 6*: Such expressions may be used as bit-field lengths
+[[class.bit]], as enumerator initializers if the underlying type is not
+fixed [[dcl.enum]], and as alignments [[dcl.align]]. — *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 4*:
+``` cpp
+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
 - user-defined conversions,
+- lvalue-to-rvalue conversions [[conv.lval]],
+- array-to-pointer conversions [[conv.array]],
+- function-to-pointer conversions [[conv.func]],
+- qualification conversions [[conv.qual]],
+- integral promotions [[conv.prom]],
+- integral conversions [[conv.integral]] other than narrowing
+  conversions [[dcl.init.list]],
+- null pointer conversions [[conv.ptr]] from `std::nullptr_t`,
+- null member pointer conversions [[conv.mem]] from `std::nullptr_t`,
   and
+- function pointer conversions [[conv.fctptr]],
 and where the reference binding (if any) binds directly.
+[*Note 7*: Such expressions may 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]], and as non-type template arguments
+[[temp.arg]]. — *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.
 A *constant expression* is either a glvalue core constant expression
 that refers to an entity that is a permitted result of a constant
 expression (as defined below), or a prvalue core constant expression
 - if the value is an object of class type, each non-static data member
   of reference type refers to an entity that is a permitted result of a
   constant expression,
 - if the value is of pointer type, it contains the address of an object
   with static storage duration, the address past the end of such an
+  object [[expr.add]], the address of a non-immediate function, or a
+ null pointer value,
+- if the value is of pointer-to-member-function type, it does not
+  designate an immediate function, and
 - if the value is an object of class or array type, each subobject
   satisfies these constraints for the value.
 An entity is a *permitted result of a constant expression* if it is an
+object with static storage duration that either is not a temporary
 object or is a temporary object whose value satisfies the above
+constraints, or if it is a non-immediate function.
+[*Example 5*:
+``` cpp
+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
+```
+— *end example*]
+[*Note 8*:
+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.[^32]
+[*Example 6*:
 ``` cpp
 bool f() {
     char array[1 + int(1 + 0.2 - 0.1 - 0.1)];   // Must be evaluated during translation
     int size = 1 + int(1 + 0.2 - 0.1 - 0.1);    // May be evaluated at runtime
 — *end example*]
 — *end note*]
+An expression or conversion is in an *immediate function context* if it
+is potentially evaluated and its innermost non-block scope is a function
+parameter scope of an immediate function. An expression or conversion 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 immediate invocation shall be a constant
+expression.
+An expression or conversion is *manifestly constant-evaluated* if it is:
+- a *constant-expression*, or
+- the condition of a constexpr if statement [[stmt.if]], or
+- an immediate invocation, or
+- the result of substitution into an atomic constraint expression to
+  determine whether it is satisfied [[temp.constr.atomic]], or
+- the initializer of a variable that is usable in constant expressions
+  or has constant initialization.[^33]
+  \[*Example 7*:
   ``` cpp
+  template<bool> struct X {};
+ X<std::is_constant_evaluated()> x;                      // type X<true>
+  int y;
+ const int a = std::is_constant_evaluated() ? y : 1;     // dynamic initialization to 1
+  double z[a];                                            // error: a is not usable
+                                                          // in constant expressions
+  const int b = std::is_constant_evaluated() ? 2 : y;     // static initialization to 2
+ int c = y + (std::is_constant_evaluated() ? 2 : y);     // 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;       // m might be 13 or 17 (see below)
+    char arr[n] = {}; // char[13]
+    return m + sizeof(arr);
+  }
+  int p = f();                                            // m is 13; initialized to 26
+  int q = p + f();                                        // m is 17 for this call; initialized to 56
   ```
   — *end example*]
+[*Note 9*: A manifestly constant-evaluated expression is evaluated even
+in an unevaluated operand. — *end note*]
+An expression or conversion is *potentially constant evaluated* if it
+is:
+- a manifestly constant-evaluated expression,
+- a potentially-evaluated expression [[basic.def.odr]],
+- an immediate subexpression of a *braced-init-list*, [^34]
+- an expression of the form `&` *cast-expression* that occurs within a
+  templated entity, [^35] or
+- a subexpression of one of the above that is not a subexpression of a
+  nested unevaluated operand.
+A function or variable is *needed for constant evaluation* if it is:
+- a constexpr function that is named by an expression [[basic.def.odr]]
+  that is potentially constant evaluated, or
+- a variable whose name appears as a potentially constant evaluated
+  expression that is either a constexpr variable or is of non-volatile
+  const-qualified integral type or of reference type.
 <!-- Link reference definitions -->
+[allocator.members]: utilities.md#allocator.members
+[bad.alloc]: support.md#bad.alloc
+[bad.cast]: support.md#bad.cast
+[bad.typeid]: support.md#bad.typeid
 [basic.align]: basic.md#basic.align
 [basic.compound]: basic.md#basic.compound
 [basic.def.odr]: basic.md#basic.def.odr
 [basic.fundamental]: basic.md#basic.fundamental
+[basic.indet]: basic.md#basic.indet
 [basic.life]: basic.md#basic.life
 [basic.lookup]: basic.md#basic.lookup
 [basic.lookup.argdep]: basic.md#basic.lookup.argdep
 [basic.lookup.classref]: basic.md#basic.lookup.classref
 [basic.lookup.unqual]: basic.md#basic.lookup.unqual
+[basic.lval]: #basic.lval
 [basic.namespace]: dcl.md#basic.namespace
 [basic.scope.block]: basic.md#basic.scope.block
 [basic.scope.class]: basic.md#basic.scope.class
 [basic.start.main]: basic.md#basic.start.main
 [basic.stc.dynamic]: basic.md#basic.stc.dynamic
 [basic.types]: basic.md#basic.types
 [class]: class.md#class
 [class.abstract]: class.md#class.abstract
 [class.access]: class.md#class.access
 [class.access.base]: class.md#class.access.base
+[class.base.init]: class.md#class.base.init
 [class.bit]: class.md#class.bit
+[class.cdtor]: class.md#class.cdtor
+[class.conv]: class.md#class.conv
+[class.conv.fct]: class.md#class.conv.fct
+[class.copy.assign]: class.md#class.copy.assign
+[class.copy.ctor]: class.md#class.copy.ctor
+[class.copy.elision]: class.md#class.copy.elision
+[class.ctor]: class.md#class.ctor
 [class.derived]: class.md#class.derived
+[class.dtor]: class.md#class.dtor
+[class.free]: class.md#class.free
 [class.friend]: class.md#class.friend
 [class.mem]: class.md#class.mem
 [class.member.lookup]: class.md#class.member.lookup
 [class.mfct]: class.md#class.mfct
 [class.mfct.non-static]: class.md#class.mfct.non-static
+[class.mi]: class.md#class.mi
+[class.prop]: class.md#class.prop
 [class.qual]: basic.md#class.qual
+[class.spaceship]: class.md#class.spaceship
 [class.static]: class.md#class.static
+[class.temporary]: basic.md#class.temporary
 [class.this]: class.md#class.this
 [class.union]: class.md#class.union
 [class.virtual]: class.md#class.virtual
+[cmp.categories]: support.md#cmp.categories
+[conv]: #conv
+[conv.array]: #conv.array
+[conv.bool]: #conv.bool
+[conv.double]: #conv.double
+[conv.fctptr]: #conv.fctptr
+[conv.fpint]: #conv.fpint
+[conv.fpprom]: #conv.fpprom
+[conv.func]: #conv.func
+[conv.integral]: #conv.integral
+[conv.lval]: #conv.lval
+[conv.mem]: #conv.mem
+[conv.prom]: #conv.prom
+[conv.ptr]: #conv.ptr
+[conv.qual]: #conv.qual
+[conv.rank]: basic.md#conv.rank
+[conv.rval]: #conv.rval
 [cpp]: cpp.md#cpp
+[cstdarg.syn]: support.md#cstdarg.syn
+[cstddef.syn]: support.md#cstddef.syn
 [dcl.align]: dcl.md#dcl.align
 [dcl.array]: dcl.md#dcl.array
+[dcl.asm]: dcl.md#dcl.asm
 [dcl.constexpr]: dcl.md#dcl.constexpr
 [dcl.dcl]: dcl.md#dcl.dcl
+[dcl.decl]: dcl.md#dcl.decl
 [dcl.enum]: dcl.md#dcl.enum
 [dcl.fct]: dcl.md#dcl.fct
 [dcl.fct.def]: dcl.md#dcl.fct.def
+[dcl.fct.def.coroutine]: dcl.md#dcl.fct.def.coroutine
 [dcl.fct.def.general]: dcl.md#dcl.fct.def.general
 [dcl.fct.default]: dcl.md#dcl.fct.default
 [dcl.init]: dcl.md#dcl.init
 [dcl.init.aggr]: dcl.md#dcl.init.aggr
 [dcl.init.list]: dcl.md#dcl.init.list
 [dcl.init.ref]: dcl.md#dcl.init.ref
+[dcl.init.string]: dcl.md#dcl.init.string
 [dcl.link]: dcl.md#dcl.link
+[dcl.mptr]: dcl.md#dcl.mptr
 [dcl.name]: dcl.md#dcl.name
+[dcl.ptr]: dcl.md#dcl.ptr
 [dcl.ref]: dcl.md#dcl.ref
 [dcl.spec.auto]: dcl.md#dcl.spec.auto
 [dcl.stc]: dcl.md#dcl.stc
 [dcl.struct.bind]: dcl.md#dcl.struct.bind
 [dcl.type]: dcl.md#dcl.type
 [dcl.type.cv]: dcl.md#dcl.type.cv
 [dcl.type.simple]: dcl.md#dcl.type.simple
+[defns.access]: intro.md#defns.access
+[depr.arith.conv.enum]: future.md#depr.arith.conv.enum
+[depr.array.comp]: future.md#depr.array.comp
+[depr.capture.this]: future.md#depr.capture.this
+[depr.comma.subscript]: future.md#depr.comma.subscript
+[depr.volatile.type]: future.md#depr.volatile.type
 [except]: except.md#except
 [except.handle]: except.md#except.handle
+[except.pre]: except.md#except.pre
 [except.spec]: except.md#except.spec
 [except.terminate]: except.md#except.terminate
 [except.throw]: except.md#except.throw
 [expr]: #expr
 [expr.add]: #expr.add
 [expr.alignof]: #expr.alignof
+[expr.arith.conv]: #expr.arith.conv
 [expr.ass]: #expr.ass
+[expr.await]: #expr.await
 [expr.bit.and]: #expr.bit.and
 [expr.call]: #expr.call
 [expr.cast]: #expr.cast
 [expr.comma]: #expr.comma
+[expr.compound]: #expr.compound
 [expr.cond]: #expr.cond
 [expr.const]: #expr.const
 [expr.const.cast]: #expr.const.cast
+[expr.context]: #expr.context
 [expr.delete]: #expr.delete
 [expr.dynamic.cast]: #expr.dynamic.cast
 [expr.eq]: #expr.eq
 [expr.log.and]: #expr.log.and
 [expr.log.or]: #expr.log.or
 [expr.mul]: #expr.mul
 [expr.new]: #expr.new
 [expr.or]: #expr.or
 [expr.post]: #expr.post
 [expr.post.incr]: #expr.post.incr
+[expr.pre]: #expr.pre
 [expr.pre.incr]: #expr.pre.incr
 [expr.prim]: #expr.prim
 [expr.prim.fold]: #expr.prim.fold
 [expr.prim.id]: #expr.prim.id
+[expr.prim.id.dtor]: #expr.prim.id.dtor
 [expr.prim.id.qual]: #expr.prim.id.qual
 [expr.prim.id.unqual]: #expr.prim.id.unqual
 [expr.prim.lambda]: #expr.prim.lambda
 [expr.prim.lambda.capture]: #expr.prim.lambda.capture
 [expr.prim.lambda.closure]: #expr.prim.lambda.closure
 [expr.prim.literal]: #expr.prim.literal
 [expr.prim.paren]: #expr.prim.paren
+[expr.prim.req]: #expr.prim.req
+[expr.prim.req.compound]: #expr.prim.req.compound
+[expr.prim.req.nested]: #expr.prim.req.nested
+[expr.prim.req.simple]: #expr.prim.req.simple
+[expr.prim.req.type]: #expr.prim.req.type
 [expr.prim.this]: #expr.prim.this
+[expr.prop]: #expr.prop
 [expr.ref]: #expr.ref
 [expr.reinterpret.cast]: #expr.reinterpret.cast
 [expr.rel]: #expr.rel
 [expr.shift]: #expr.shift
 [expr.sizeof]: #expr.sizeof
+[expr.spaceship]: #expr.spaceship
 [expr.static.cast]: #expr.static.cast
 [expr.sub]: #expr.sub
 [expr.throw]: #expr.throw
+[expr.type]: #expr.type
 [expr.type.conv]: #expr.type.conv
 [expr.typeid]: #expr.typeid
 [expr.unary]: #expr.unary
 [expr.unary.noexcept]: #expr.unary.noexcept
 [expr.unary.op]: #expr.unary.op
 [expr.xor]: #expr.xor
+[expr.yield]: #expr.yield
 [function.objects]: utilities.md#function.objects
 [implimits]: limits.md#implimits
 [intro]: intro.md#intro
+[intro.execution]: basic.md#intro.execution
+[intro.memory]: basic.md#intro.memory
+[intro.object]: basic.md#intro.object
+[lex.ext]: lex.md#lex.ext
+[lex.icon]: lex.md#lex.icon
 [lex.literal]: lex.md#lex.literal
 [lex.string]: lex.md#lex.string
 [library]: library.md#library
+[meta.const.eval]: utilities.md#meta.const.eval
 [namespace.qual]: basic.md#namespace.qual
+[new.badlength]: support.md#new.badlength
+[new.delete.array]: support.md#new.delete.array
+[new.delete.placement]: support.md#new.delete.placement
+[new.delete.single]: support.md#new.delete.single
 [over]: over.md#over
 [over.ass]: over.md#over.ass
 [over.best.ics]: over.md#over.best.ics
 [over.built]: over.md#over.built
 [over.call]: over.md#over.call
 [over.match.oper]: over.md#over.match.oper
 [over.match.viable]: over.md#over.match.viable
 [over.oper]: over.md#over.oper
 [over.over]: over.md#over.over
 [replacement.functions]: library.md#replacement.functions
+[special]: class.md#special
+[stmt.if]: stmt.md#stmt.if
+[stmt.iter]: stmt.md#stmt.iter
+[stmt.jump]: stmt.md#stmt.jump
 [stmt.return]: stmt.md#stmt.return
 [stmt.switch]: stmt.md#stmt.switch
+[support.runtime]: support.md#support.runtime
+[support.types.layout]: support.md#support.types.layout
 [temp.arg]: temp.md#temp.arg
+[temp.concept]: temp.md#temp.concept
+[temp.constr.atomic]: temp.md#temp.constr.atomic
+[temp.constr.constr]: temp.md#temp.constr.constr
+[temp.constr.decl]: temp.md#temp.constr.decl
+[temp.dep.constexpr]: temp.md#temp.dep.constexpr
 [temp.expl.spec]: temp.md#temp.expl.spec
 [temp.explicit]: temp.md#temp.explicit
 [temp.names]: temp.md#temp.names
+[temp.param]: temp.md#temp.param
+[temp.pre]: temp.md#temp.pre
 [temp.res]: temp.md#temp.res
 [temp.variadic]: temp.md#temp.variadic
 [thread]: thread.md#thread
+[type.info]: support.md#type.info
 [^1]: The precedence of operators is not directly specified, but it can
     be derived from the syntax.
+[^2]: Overloaded operators are never assumed to be associative or
+ commutative.
 [^3]: The cast and assignment operators must still perform their
+    specific conversions as described in  [[expr.type.conv]],
+    [[expr.cast]], [[expr.static.cast]] and  [[expr.ass]].
+[^4]: The intent of this list is to specify those circumstances in which
+    an object may or may not be aliased.
+[^5]: For historical reasons, this conversion is called the
+    “lvalue-to-rvalue” conversion, even though that name does not
+    accurately reflect the taxonomy of expressions described in
+    [[basic.lval]].
+[^6]: In C++ class and array prvalues can have cv-qualified types. This
+    differs from ISO C, in which non-lvalues never have cv-qualified
+    types.
+[^7]: This conversion never applies to non-static member functions
+    because an lvalue that refers to a non-static member function cannot
+    be obtained.
+[^8]: The rule for conversion of pointers to members (from pointer to
+    member of base to pointer to member of derived) appears inverted
+    compared to the rule for pointers to objects (from pointer to
+    derived to pointer to base) ([[conv.ptr]], [[class.derived]]). This
+    inversion is necessary to ensure type safety. Note that a pointer to
+    member is not an object pointer or a function pointer and the rules
+    for conversions of such pointers do not apply to pointers to
+    members. In particular, a pointer to member cannot be converted to a
+    `void*`.
+[^9]: As a consequence, operands of type `bool`, `char8_t`, `char16_t`,
+    `char32_t`, `wchar_t`, or an enumerated type are converted to some
+    integral type.
+[^10]: This also applies when the object expression is an implicit
     `(*this)` ([[class.mfct.non-static]]).
+[^11]: This is true even if the subscript operator is used in the
     following common idiom: `&x[0]`.
+[^12]: If the class member access expression is evaluated, the
     subexpression evaluation happens even if the result is unnecessary
     to determine the value of the entire postfix expression, for example
     if the *id-expression* denotes a static member.
+[^13]: Note that `(*(E1))` is an lvalue.
+[^14]: The most derived object [[intro.object]] pointed or referred to
     by `v` can contain other `B` objects as base classes, but these are
     ignored.
+[^15]: The recommended name for such a class is `extended_type_info`.
+[^16]: If `p` is an expression of pointer type, then `*p`, `(*p)`,
     `*(p)`, `((*p))`, `*((p))`, and so on all meet this requirement.
+[^17]: The types may have different cv-qualifiers, subject to the
     overall restriction that a `reinterpret_cast` cannot cast away
     constness.
+[^18]: `T1` and `T2` may have different cv-qualifiers, subject to the
     overall restriction that a `reinterpret_cast` cannot cast away
     constness.
+[^19]: This is sometimes referred to as a *type pun* when the result
+    refers to the same object as the source glvalue.
+[^20]: `const_cast`
     is not limited to conversions that cast away a const-qualifier.
+[^21]: `sizeof(bool)` is not required to be `1`.
+[^22]: The actual size of a potentially-overlapping subobject may be
+ less than the result of applying `sizeof` to the subobject, due to
+ virtual base classes and less strict padding requirements on
+ potentially-overlapping subobjects.
+[^23]: If the conversion function returns a signed integer type, the
     second standard conversion converts to the unsigned type
     `std::size_t` and thus thwarts any attempt to detect a negative
     value afterwards.
+[^24]: This may include evaluating a *new-initializer* and/or calling a
     constructor.
+[^25]: A *lambda-expression* with a *lambda-introducer* that consists of
+    empty square brackets can follow the `delete` keyword if the
+ *lambda-expression* is enclosed in parentheses.
+[^26]: This implies that an object cannot be deleted using a pointer of
     type `void*` because `void` is not an object type.
+[^27]: For nonzero-length arrays, this is the same as a pointer to the
     first element of the array created by that *new-expression*.
     Zero-length arrays do not have a first element.
+[^28]: This is often called truncation towards zero.
+[^29]: As specified in [[basic.compound]], an object that is not an
+    array element is considered to belong to a single-element array for
+    this purpose and a pointer past the last element of an array of n
+    elements is considered to be equivalent to a pointer to a
+    hypothetical array element n for this purpose.
+[^30]: As specified in [[basic.compound]], an object that is not an
+ array element is considered to belong to a single-element array for
+ this purpose and a pointer past the last element of an array of n
+ elements is considered to be equivalent to a pointer to a
+ hypothetical array element n for this purpose.
+[^31]: As specified in [[basic.compound]], an object that is not an
+ array element is considered to belong to a single-element array for
+ this purpose.
+[^32]: Nonetheless, implementations should provide consistent results,
+ irrespective of whether the evaluation was performed during
     translation and/or during program execution.
+[^33]: Testing this condition may involve a trial evaluation of its
+    initializer as described above.
+[^34]: Constant evaluation may be necessary to determine whether a
+    narrowing conversion is performed [[dcl.init.list]].
+[^35]: Constant evaluation may be necessary to determine whether such an
+    expression is value-dependent [[temp.dep.constexpr]].

Diff to HTML by rtfpessoa