[expr.const] - C++11 → C++14

Files changed (1) hide show

tmp/tmporgv2in8/{from.md → to.md} +152 -122

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

@@ -10,126 +10,147 @@ during translation.
 ``` bnf
 constant-expression:
     conditional-expression
 ```
-A *conditional-expression* is a *core constant expression* unless it
-involves one of the following as a potentially evaluated subexpression (
-[[basic.def.odr]]), but subexpressions of logical AND (
-[[expr.log.and]]), logical OR ([[expr.log.or]]), and conditional (
-[[expr.cond]]) operations that are not evaluated are not considered An
-overloaded operator invokes a function.:
-- `this` ([[expr.prim]]) unless it appears as the *postfix-expression*
- in a class member access expression, including the result of the
-  implicit transformation in the body of a non-static member function (
-  [[class.mfct.non-static]]);
 - an invocation of a function other than a `constexpr` constructor for a
-  literal class or a `constexpr` function Overload resolution (
   [[over.match]]) is applied as usual ;
 - an invocation of an undefined `constexpr` function or an undefined
-  `constexpr` constructor outside the definition of a `constexpr`
-  function or a `constexpr` constructor;
-- an invocation of a `constexpr` function with arguments that, when
-  substituted by function invocation substitution ([[dcl.constexpr]]),
-  do not produce a constant expression;
-  ``` cpp
-  constexpr const int* addr(const int& ir) { return &ir; }  // OK
-  static const int x = 5;
-  constexpr const int* xp = addr(x);  // OK: (const int*)&(const int&)x is an
-                                      // address constant expression
-  constexpr const int* tp = addr(5);  // error, initializer for constexpr variable not a constant
-                                      // expression; (const int*)&(const int&)5 is not a constant
-                                      // expression because it takes the address of a temporary
-  ```
-- an invocation of a `constexpr` constructor with arguments that, when
-  substituted by function invocation substitution ([[dcl.constexpr]]),
-  do not produce all constant expressions for the constructor calls and
-  full-expressions in the *mem-initializer*s;
-  ``` cpp
-  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 after substitution
-  constexpr int w = A(false).m;       // error: initializer for m is
-                                      // x, which is non-constant
-  ```
-- an invocation of a `constexpr` function or a `constexpr` constructor
-  that would exceed the implementation-defined recursion limits (see
   Annex  [[implimits]]);
-- a result that is not mathematically defined or not in the range of
- representable values for its type;
 - a *lambda-expression* ([[expr.prim.lambda]]);
 - an lvalue-to-rvalue conversion ([[conv.lval]]) unless it is applied
   to
-  - a glvalue of integral or enumeration type that refers to a
-    non-volatile const object with a preceding initialization,
-    initialized with a constant expression, or
-  - a glvalue of literal type that refers to a non-volatile object
-    defined with `constexpr`, or that refers to a sub-object of such an
- object, or
-  - a glvalue of literal type that refers to a non-volatile temporary
-    object whose lifetime has not ended, initialized with a constant
- expression;
-- 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 *id-expression* that refers to a variable or data member of
-  reference type unless the reference has a preceding initialization,
- initialized with a constant expression;
 - a dynamic cast ([[expr.dynamic.cast]]);
 - a `reinterpret_cast` ([[expr.reinterpret.cast]]);
 - a pseudo-destructor call ([[expr.pseudo]]);
-- increment or decrement operations ([[expr.post.incr]],
-  [[expr.pre.incr]]);
-- a typeid expression ([[expr.typeid]]) whose operand is of a
   polymorphic class type;
 - a *new-expression* ([[expr.new]]);
 - a *delete-expression* ([[expr.delete]]);
-- a subtraction ([[expr.add]]) where both operands are pointers;
 - a relational ([[expr.rel]]) or equality ([[expr.eq]]) operator where
-  the result is unspecified;
-- an assignment or a compound assignment ([[expr.ass]]); or
 - a *throw-expression* ([[except.throw]]).
-A *literal constant expression* is a prvalue core constant expression of
-literal type, but not pointer type. An *integral constant expression* is
-a literal constant expression of integral or unscoped enumeration type.
-Such expressions may be used as array bounds ([[dcl.array]],
-[[expr.new]]), as bit-field lengths ([[class.bit]]), as enumerator
-initializers if the underlying type is not fixed ([[dcl.enum]]), as
-null pointer constants ([[conv.ptr]]), and as alignments (
-[[dcl.align]]). A *converted constant expression* of type `T` is a
-literal constant expression, implicitly converted to type `T`, where the
-implicit conversion (if any) is permitted in a literal constant
-expression and the implicit conversion sequence contains only
-user-defined conversions, lvalue-to-rvalue conversions ([[conv.lval]]),
-integral promotions ([[conv.prom]]), and integral conversions (
-[[conv.integral]]) other than narrowing conversions (
-[[dcl.init.list]]). such expressions may be used as case expressions (
-[[stmt.switch]]), as enumerator initializers if the underlying type is
-fixed ([[dcl.enum]]), and as integral or enumeration non-type template
-arguments ([[temp.arg]]). A *reference constant expression* is an
-lvalue core constant expression that designates an object with static
-storage duration or a function. An *address constant expression* is a
-prvalue core constant expression of pointer type that evaluates to the
-address of an object with static storage duration, to the address of a
-function, or to a null pointer value, or a prvalue core constant
-expression of type `std::nullptr_t`. Collectively, literal constant
-expressions, reference constant expressions, and address constant
-expressions are called *constant expressions*.
-Although in some contexts constant expressions must be evaluated during
-program translation, others may be evaluated during program execution.
 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.[^27]
 ``` 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
@@ -138,20 +159,20 @@ bool f() {
 ```
 It is unspecified whether the value of `f()` will be `true` or `false`.
 If an expression of literal class type is used in a context where an
-integral constant expression is required, then that class type shall
-have a single non-explicit conversion function to an integral or
-unscoped enumeration type and that conversion function shall be
 `constexpr`.
 ``` cpp
 struct A {
   constexpr A(int i) : val(i) { }
-  constexpr operator int() { return val; }
-  constexpr operator long() { return 43; }
 private:
   int val;
 };
 template<int> struct X { };
 constexpr A a = 42;
@@ -171,12 +192,12 @@ int ary[a];         // error: ambiguous conversion
 [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.class]: basic.md#basic.scope.class
-[basic.scope.local]: basic.md#basic.scope.local
 [basic.start.main]: basic.md#basic.start.main
 [basic.stc.dynamic]: basic.md#basic.stc.dynamic
 [basic.stc.dynamic.allocation]: basic.md#basic.stc.dynamic.allocation
 [basic.stc.dynamic.deallocation]: basic.md#basic.stc.dynamic.deallocation
 [basic.stc.dynamic.safety]: basic.md#basic.stc.dynamic.safety
@@ -219,16 +240,16 @@ int ary[a];         // error: ambiguous conversion
 [conv.prom]: conv.md#conv.prom
 [conv.ptr]: conv.md#conv.ptr
 [conv.qual]: conv.md#conv.qual
 [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.delete]: dcl.md#dcl.fct.def.delete
 [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
@@ -298,20 +319,22 @@ int ary[a];         // error: ambiguous conversion
 [new.delete.single]: language.md#new.delete.single
 [over]: over.md#over
 [over.ass]: over.md#over.ass
 [over.built]: over.md#over.built
 [over.call]: over.md#over.call
 [over.literal]: over.md#over.literal
 [over.match]: over.md#over.match
 [over.match.oper]: over.md#over.match.oper
 [over.oper]: over.md#over.oper
 [over.over]: over.md#over.over
 [replacement.functions]: library.md#replacement.functions
 [stmt.switch]: stmt.md#stmt.switch
 [support.runtime]: language.md#support.runtime
 [support.types]: language.md#support.types
 [temp.arg]: temp.md#temp.arg
 [temp.names]: temp.md#temp.names
 [temp.res]: temp.md#temp.res
 [temp.variadic]: temp.md#temp.variadic
 [type.info]: language.md#type.info
@@ -330,53 +353,55 @@ int ary[a];         // error: ambiguous conversion
     `(*this)` ([[class.mfct.non-static]]).
 [^5]: This is true even if the subscript operator is used in the
     following common idiom: `&x[0]`.
-[^6]: A static member function ([[class.static]]) is an ordinary
-    function.
-[^7]: 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.
-[^8]: Note that `(*(E1))` is an lvalue.
-[^9]: The most derived object ([[intro.object]]) pointed or referred to
     by `v` can contain other `B` objects as base classes, but these are
     ignored.
-[^10]: The recommended name for such a class is `extended_type_info`.
-[^11]: If `p` is an expression of pointer type, then `*p`, `(*p)`,
     `*(p)`, `((*p))`, `*((p))`, and so on all meet this requirement.
-[^12]: Function types (including those used in pointer to member
     function types) are never cv-qualified; see  [[dcl.fct]].
-[^13]: The types may have different cv-qualifiers, subject to the
     overall restriction that a `reinterpret_cast` cannot cast away
     constness.
-[^14]: `T1` and `T2` may have different cv-qualifiers, subject to the
     overall restriction that a `reinterpret_cast` cannot cast away
     constness.
-[^15]: This is sometimes referred to as a *type pun*.
-[^16]: `const_cast`
     is not limited to conversions that cast away a const-qualifier.
-[^17]: `sizeof(bool)` is not required to be `1`.
-[^18]: 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.
 [^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
@@ -387,16 +412,21 @@ int ary[a];         // error: ambiguous conversion
 [^22]: For non-zero-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]: This includes implicit calls such as the call to an allocation
     function in a *new-expression*.
-[^24]: This is often called truncation towards zero.
-[^25]: Another way to approach pointer arithmetic is first to convert
     the pointer(s) to character pointer(s): In this scheme the integral
     value of the expression added to or subtracted from the converted
     pointer is first multiplied by the size of the object originally
     pointed to, and the resulting pointer is converted back to the
     original type. For pointer subtraction, the result of the difference
@@ -406,13 +436,13 @@ int ary[a];         // error: ambiguous conversion
     When viewed in this way, an implementation need only provide one
     extra byte (which might overlap another object in the program) just
     after the end of the object in order to satisfy the “one past the
     last element” requirements.
-[^26]: However, an invocation of an overloaded comma operator is an
     ordinary function call; hence, the evaluations of its argument
     expressions are unsequenced relative to one another (see
     [[intro.execution]]).
-[^27]: Nonetheless, implementations are encouraged to provide consistent
-    results, irrespective of whether the evaluation was actually
- performed during translation or during program execution.

 ``` bnf
 constant-expression:
     conditional-expression
 ```
+A *conditional-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.general]]), 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]]) Overload resolution (
   [[over.match]]) is applied as usual ;
 - an invocation of an undefined `constexpr` function or an undefined
+  `constexpr` constructor;
+- an expression that would exceed the implementation-defined limits (see
   Annex  [[implimits]]);
+- an operation that would have undefined behavior including, for
+ example, signed integer overflow (Clause [[expr]]), certain pointer
+  arithmetic ([[expr.add]]), division by zero ([[expr.mul]]), or
+  certain shift operations ([[expr.shift]]) ;
 - a *lambda-expression* ([[expr.prim.lambda]]);
 - 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 non-volatile const object with a preceding initialization,
+    initialized with a constant expression a string literal (
+    [[lex.string]]) corresponds to an array of such objects. , or
+  - a non-volatile glvalue that refers to a non-volatile object defined
+ with `constexpr`, or that refers to a non-mutable sub-object 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]]) or modification (
+ [[expr.ass]], [[expr.post.incr]], [[expr.pre.incr]]) that is applied
+ to a glvalue that refers to a non-active member of a union or a
+  subobject thereof;
 - 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
+  - it is a non-static data member of an object whose 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]]);
+- 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* ([[except.throw]]).
+``` cpp
+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);                  // OK: incr(k) is not required to be 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 h(1)
+```
+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. Such expressions may
+be used as array bounds ([[dcl.array]], [[expr.new]]), as bit-field
+lengths ([[class.bit]]), as enumerator initializers if the underlying
+type is not fixed ([[dcl.enum]]), and as alignments ([[dcl.align]]). A
+*converted constant expression* of type `T` is an expression, implicitly
+converted to a prvalue of type `T`, where the converted expression is a
+core constant expression and the implicit conversion sequence contains
+only user-defined conversions, lvalue-to-rvalue conversions (
+[[conv.lval]]), integral promotions ([[conv.prom]]), and integral
+conversions ([[conv.integral]]) other than narrowing conversions (
+[[dcl.init.list]]). 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 integral or enumeration non-type
+template arguments ([[temp.arg]]).
+A *constant expression* is either a glvalue core constant expression
+whose value refers to an object with static storage duration or to a
+function, or a prvalue core constant expression whose value is an object
+where, for that object and its subobjects:
+- each non-static data member of reference type refers to an object with
+  static storage duration or to a function, and
+- if the object or subobject 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.
 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]
 ``` 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
 ```
 It is unspecified whether the value of `f()` will be `true` or `false`.
 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`.
 ``` 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;
 [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
 [basic.stc.dynamic.allocation]: basic.md#basic.stc.dynamic.allocation
 [basic.stc.dynamic.deallocation]: basic.md#basic.stc.dynamic.deallocation
 [basic.stc.dynamic.safety]: basic.md#basic.stc.dynamic.safety
 [conv.prom]: conv.md#conv.prom
 [conv.ptr]: conv.md#conv.ptr
 [conv.qual]: conv.md#conv.qual
 [dcl.align]: dcl.md#dcl.align
 [dcl.array]: dcl.md#dcl.array
 [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.delete]: dcl.md#dcl.fct.def.delete
+[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
 [new.delete.single]: language.md#new.delete.single
 [over]: over.md#over
 [over.ass]: over.md#over.ass
 [over.built]: over.md#over.built
 [over.call]: over.md#over.call
+[over.ics.user]: over.md#over.ics.user
 [over.literal]: over.md#over.literal
 [over.match]: over.md#over.match
 [over.match.oper]: over.md#over.match.oper
 [over.oper]: over.md#over.oper
 [over.over]: over.md#over.over
 [replacement.functions]: library.md#replacement.functions
 [stmt.switch]: stmt.md#stmt.switch
 [support.runtime]: language.md#support.runtime
 [support.types]: language.md#support.types
 [temp.arg]: temp.md#temp.arg
+[temp.mem]: temp.md#temp.mem
 [temp.names]: temp.md#temp.names
 [temp.res]: temp.md#temp.res
 [temp.variadic]: temp.md#temp.variadic
 [type.info]: language.md#type.info
     `(*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
 [^22]: For non-zero-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 includes implicit calls such as the call to an allocation
     function in a *new-expression*.
+[^25]: This is often called truncation towards zero.
+[^26]: Another way to approach pointer arithmetic is first to convert
     the pointer(s) to character pointer(s): In this scheme the integral
     value of the expression added to or subtracted from the converted
     pointer is first multiplied by the size of the object originally
     pointed to, and the resulting pointer is converted back to the
     original type. For pointer subtraction, the result of the difference
     When viewed in this way, an implementation need only provide one
     extra byte (which might overlap another object in the program) just
     after the end of the object in order to satisfy the “one past the
     last element” requirements.
+[^27]: However, an invocation of an overloaded comma operator is an
     ordinary function call; hence, the evaluations of its argument
     expressions are unsequenced relative to one another (see
     [[intro.execution]]).
+[^28]: Nonetheless, implementations are encouraged to provide consistent
+    results, irrespective of whether the evaluation was performed during
+    translation and/or during program execution.

Diff to HTML by rtfpessoa