[expr.post] - C++20 → C++23

Files changed (1) hide show

tmp/tmpfygugu0r/{from.md → to.md} +231 -163

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

@@ -1,22 +1,24 @@
 ### Postfix expressions <a id="expr.post">[[expr.post]]</a>
 Postfix expressions group left-to-right.
 ``` bnf
 postfix-expression:
     primary-expression
-    postfix-expression '[' expr-or-braced-init-list ']'
     postfix-expression '(' expression-listₒₚₜ ')'
     simple-type-specifier '(' expression-listₒₚₜ ')'
     typename-specifier '(' expression-listₒₚₜ ')'
     simple-type-specifier braced-init-list
     typename-specifier braced-init-list
     postfix-expression '.' 'template'ₒₚₜ id-expression
     postfix-expression '->' 'template'ₒₚₜ id-expression
     postfix-expression '++'
-    postfix-expression '-{-}'
     dynamic_cast '<' type-id '>' '(' expression ')'
     static_cast '<' type-id '>' '(' expression ')'
     reinterpret_cast '<' type-id '>' '(' expression ')'
     const_cast '<' type-id '>' '(' expression ')'
     typeid '(' expression ')'
@@ -27,38 +29,43 @@ postfix-expression:
 expression-list:
     initializer-list
 ```
 [*Note 1*: The `>` token following the *type-id* in a `dynamic_cast`,
-`static_cast`, `reinterpret_cast`, or `const_cast` may be the product of
-replacing a `>{>}` token by two consecutive `>` tokens
 [[temp.names]]. — *end note*]
 #### Subscripting <a id="expr.sub">[[expr.sub]]</a>
-A postfix expression followed by an expression in square brackets is a
-postfix expression. One of the expressions shall be a glvalue of type
-“array of `T`” or a prvalue of type “pointer to `T`” and the other shall
-be a prvalue of unscoped enumeration or integral type. The result is of
-type “`T`”. The type “`T`” shall be a completely-defined object
-type.[^11] The expression `E1[E2]` is identical (by definition) to
-`*((E1)+(E2))`, except that in the case of an array operand, the result
-is an lvalue if that operand is an lvalue and an xvalue otherwise. The
-expression `E1` is sequenced before the expression `E2`.
-[*Note 1*: A comma expression [[expr.comma]] appearing as the
-*expr-or-braced-init-list* of a subscripting expression is deprecated;
-see [[depr.comma.subscript]]. — *end note*]
-[*Note 2*: Despite its asymmetric appearance, subscripting is a
 commutative operation except for sequencing. See  [[expr.unary]] and
 [[expr.add]] for details of `*` and `+` and  [[dcl.array]] for details
 of array types. — *end note*]
-A *braced-init-list* shall not be used with the built-in subscript
-operator.
 #### Function call <a id="expr.call">[[expr.call]]</a>
 A function call is a postfix expression followed by parentheses
 containing a possibly empty, comma-separated list of
 *initializer-clause*s which constitute the arguments to the function.
@@ -72,72 +79,69 @@ type. For a call to a non-member function or to a static member
 function, the postfix expression shall either be an lvalue that refers
 to a function (in which case the function-to-pointer standard conversion
 [[conv.func]] is suppressed on the postfix expression), or have function
 pointer type.
-For a call to a non-static member function, the postfix expression shall
-be an implicit ([[class.mfct.non-static]], [[class.static]]) or
-explicit class member access [[expr.ref]] whose *id-expression* is a
-function member name, or a pointer-to-member expression
-[[expr.mptr.oper]] selecting a function member; the call is as a member
-of the class object referred to by the object expression. In the case of
-an implicit class member access, the implied object is the one pointed
-to by `this`.
-[*Note 2*: A member function call of the form `f()` is interpreted as
-`(*this).f()` (see  [[class.mfct.non-static]]). — *end note*]
 If the selected function is non-virtual, or if the *id-expression* in
 the class member access expression is a *qualified-id*, that function is
 called. Otherwise, its final overrider [[class.virtual]] in the dynamic
 type of the object expression is called; such a call is referred to as a
 *virtual function call*.
-[*Note 3*: The dynamic type is the type of the object referred to by
 the current value of the object expression. [[class.cdtor]] describes
 the behavior of virtual function calls when the object expression refers
 to an object under construction or destruction. — *end note*]
-[*Note 4*: If a function or member function name is used, and name
 lookup [[basic.lookup]] does not find a declaration of that name, the
 program is ill-formed. No function is implicitly declared by such a
 call. — *end note*]
 If the *postfix-expression* names a destructor or pseudo-destructor
 [[expr.prim.id.dtor]], the type of the function call expression is
 `void`; otherwise, the type of the function call expression is the
 return type of the statically chosen function (i.e., ignoring the
 `virtual` keyword), even if the type of the function actually called is
-different. This return type shall be an object type, a reference type or
-cv `void`. If the *postfix-expression* names a pseudo-destructor (in
 which case the *postfix-expression* is a possibly-parenthesized class
 member access), the function call destroys the object of scalar type
-denoted by the object expression of the class member access (
-[[expr.ref]], [[basic.life]]).
-Calling a function through an expression whose function type is
-different from the function type of the called function’s definition
-results in undefined behavior.
-When a function is called, each parameter [[dcl.fct]] is initialized (
-[[dcl.init]], [[class.copy.ctor]]) with its corresponding argument. If
-there is no corresponding argument, the default argument for the
-parameter is used.
 [*Example 1*:
 ``` cpp
 template<typename ...T> int f(int n = 0, T ...t);
 int x = f<int>();               // error: no argument for second function parameter
 ```
 — *end example*]
-If the function is a non-static member function, the `this` parameter of
-the function [[class.this]] is initialized with a pointer to the object
-of the call, converted as if by an explicit type conversion
-[[expr.cast]].
 [*Note 5*: There is no access or ambiguity checking on this conversion;
 the access checking and disambiguation are done as part of the (possibly
 implicit) class member access operator. See  [[class.member.lookup]],
 [[class.access.base]], and  [[expr.ref]]. — *end note*]
@@ -155,14 +159,14 @@ enclosing full-expression. The initialization and destruction of each
 parameter occurs within the context of the calling function.
 [*Example 2*: The access of the constructor, conversion functions or
 destructor is checked at the point of call in the calling function. If a
 constructor or destructor for a function parameter throws an exception,
-the search for a handler starts in the scope of the calling function; in
-particular, if the function called has a *function-try-block*
-[[except.pre]] with a handler that could handle the exception, this
-handler is not considered. — *end example*]
 The *postfix-expression* is sequenced before each *expression* in the
 *expression-list* and any default argument. The initialization of a
 parameter, including every associated value computation and side effect,
 is indeterminately sequenced with respect to that of any other
@@ -218,14 +222,14 @@ statically chosen function.
 parameters, but these changes cannot affect the values of the arguments
 except where a parameter is of a reference type [[dcl.ref]]; if the
 reference is to a const-qualified type, `const_cast` is required to be
 used to cast away the constness in order to modify the argument’s value.
 Where a parameter is of `const` reference type a temporary object is
-introduced if needed ([[dcl.type]], [[lex.literal]], [[lex.string]],
-[[dcl.array]], [[class.temporary]]). In addition, it is possible to
-modify the values of non-constant objects through pointer
-parameters. — *end note*]
 A function can be declared to accept fewer arguments (by declaring
 default arguments [[dcl.fct.default]]) or more arguments (by using the
 ellipsis, `...`, or a function parameter pack [[dcl.fct]]) than the
 number of parameters in the function definition [[dcl.fct.def]].
@@ -275,73 +279,93 @@ A *simple-type-specifier* [[dcl.type.simple]] or *typename-specifier*
 by a *braced-init-list* (the initializer) constructs a value of the
 specified type given the initializer. If the type is a placeholder for a
 deduced class type, it is replaced by the return type of the function
 selected by overload resolution for class template deduction
 [[over.match.class.deduct]] for the remainder of this subclause.
 If the initializer is a parenthesized single expression, the type
 conversion expression is equivalent to the corresponding cast expression
 [[expr.cast]]. Otherwise, if the type is cv `void` and the initializer
 is `()` or `{}` (after pack expansion, if any), the expression is a
-prvalue of the specified type that performs no initialization.
-Otherwise, the expression is a prvalue of the specified type whose
-result object is direct-initialized [[dcl.init]] with the initializer.
-If the initializer is a parenthesized optional *expression-list*, the
-specified type shall not be an array type.
 #### Class member access <a id="expr.ref">[[expr.ref]]</a>
 A postfix expression followed by a dot `.` or an arrow `->`, optionally
-followed by the keyword `template` [[temp.names]], and then followed by
-an *id-expression*, is a postfix expression. The postfix expression
-before the dot or arrow is evaluated;[^12] the result of that
-evaluation, together with the *id-expression*, determines the result of
-the entire postfix expression.
 For the first option (dot) the first expression shall be a glvalue. For
 the second option (arrow) the first expression shall be a prvalue having
 pointer type. The expression `E1->E2` is converted to the equivalent
 form `(*(E1)).E2`; the remainder of [[expr.ref]] will address only the
 first option (dot).[^13]
 Abbreviating *postfix-expression*`.`*id-expression* as `E1.E2`, `E1` is
 called the *object expression*. If the object expression is of scalar
 type, `E2` shall name the pseudo-destructor of that same type (ignoring
-cv-qualifications) and `E1.E2` is an lvalue of type “function of ()
 returning `void`”.
-[*Note 1*: This value can only be used for a notional function call
 [[expr.prim.id.dtor]]. — *end note*]
 Otherwise, the object expression shall be of class type. The class type
 shall be complete unless the class member access appears in the
 definition of that class.
-[*Note 2*: If the class is incomplete, lookup in the complete class
-type is required to refer to the same declaration
-[[basic.scope.class]]. — *end note*]
-The *id-expression* shall name a member of the class or of one of its
-base classes.
-[*Note 3*: Because the name of a class is inserted in its class scope
-[[class]], the name of a class is also considered a nested member of
-that class. — *end note*]
-[*Note 4*:  [[basic.lookup.classref]] describes how names are looked up
 after the `.` and `->` operators. — *end note*]
 If `E2` is a bit-field, `E1.E2` is a bit-field. The type and value
 category of `E1.E2` are determined as follows. In the remainder of
 [[expr.ref]], *cq* represents either `const` or the absence of `const`
 and *vq* represents either `volatile` or the absence of `volatile`. *cv*
 represents an arbitrary set of cv-qualifiers, as defined in
 [[basic.type.qualifier]].
 If `E2` is declared to have type “reference to `T`”, then `E1.E2` is an
-lvalue; the type of `E1.E2` is `T`. Otherwise, one of the following
-rules applies.
 - If `E2` is a static data member and the type of `E2` is `T`, then
   `E1.E2` is an lvalue; the expression designates the named member of
   the class. The type of `E1.E2` is `T`.
 - If `E2` is a non-static data member and the type of `E1` is “*cq1 vq1*
@@ -354,33 +378,53 @@ rules applies.
   *cq12* stand for the “union” of *cq1* and *cq2*; that is, if *cq1* or
   *cq2* is `const`, then *cq12* is `const`. If `E2` is declared to be a
   `mutable` member, then the type of `E1.E2` is “*vq12* `T`”. If `E2` is
   not declared to be a `mutable` member, then the type of `E1.E2` is
   “*cq12* *vq12* `T`”.
-- If `E2` is a (possibly overloaded) member function, function overload
- resolution [[over.match]] is used to select the function to which `E2`
- refers. The type of `E1.E2` is the type of `E2` and `E1.E2` refers to
- the function referred to by `E2`.
   - If `E2` refers to a static member function, `E1.E2` is an lvalue.
   - Otherwise (when `E2` refers to a non-static member function),
     `E1.E2` is a prvalue. The expression can be used only as the
     left-hand operand of a member function call [[class.mfct]].
     \[*Note 5*: Any redundant set of parentheses surrounding the
     expression is ignored [[expr.prim.paren]]. — *end note*]
 - If `E2` is a nested type, the expression `E1.E2` is ill-formed.
 - If `E2` is a member enumerator and the type of `E2` is `T`, the
-  expression `E1.E2` is a prvalue. The type of `E1.E2` is `T`.
-If `E2` is a non-static data member or a non-static member function, the
-program is ill-formed if the class of which `E2` is directly a member is
-an ambiguous base [[class.member.lookup]] of the naming class
-[[class.access.base]] of `E2`.
 [*Note 6*: The program is also ill-formed if the naming class is an
 ambiguous base of the class type of the object expression; see
 [[class.access.base]]. — *end note*]
 #### Increment and decrement <a id="expr.post.incr">[[expr.post.incr]]</a>
 The value of a postfix `++` expression is the value of its operand.
 [*Note 1*: The value obtained is a copy of the original
@@ -403,11 +447,11 @@ The result is a prvalue. The type of the result is the cv-unqualified
 version of the type of the operand. If the operand is a bit-field that
 cannot represent the incremented value, the resulting value of the
 bit-field is *implementation-defined*. See also  [[expr.add]] and
 [[expr.ass]].
-The operand of postfix `\dcr` is decremented analogously to the postfix
 `++` operator.
 [*Note 3*: For prefix increment and decrement, see
 [[expr.pre.incr]]. — *end note*]
@@ -433,13 +477,14 @@ If `T` is “pointer to *cv1* `B`” and `v` has type “pointer to *cv2* `D`”
 such that `B` is a base class of `D`, the result is a pointer to the
 unique `B` subobject of the `D` object pointed to by `v`, or a null
 pointer value if `v` is a null pointer value. Similarly, if `T` is
 “reference to *cv1* `B`” and `v` has type *cv2* `D` such that `B` is a
 base class of `D`, the result is the unique `B` subobject of the `D`
-object referred to by `v`.[^14] In both the pointer and reference cases,
-the program is ill-formed if `B` is an inaccessible or ambiguous base
-class of `D`.
 [*Example 1*:
 ``` cpp
 struct B { };
@@ -459,11 +504,11 @@ If `v` is a null pointer value, the result is a null pointer value.
 If `T` is “pointer to cv `void`”, then the result is a pointer to the
 most derived object pointed to by `v`. Otherwise, a runtime check is
 applied to see if the object pointed or referred to by `v` can be
 converted to the type pointed or referred to by `T`.
-If `C` is the class type to which `T` points or refers, the runtime
 check logically executes as follows:
 - If, in the most derived object pointed (referred) to by `v`, `v`
   points (refers) to a public base class subobject of a `C` object, and
   if only one object of type `C` is derived from the subobject pointed
@@ -517,40 +562,44 @@ destruction. — *end note*]
 The result of a `typeid` expression is an lvalue of static type `const`
 `std::type_info` [[type.info]] and dynamic type `const` `std::type_info`
 or `const` *name* where *name* is an *implementation-defined* class
 publicly derived from `std::type_info` which preserves the behavior
-described in  [[type.info]].[^15] The lifetime of the object referred to
-by the lvalue extends to the end of the program. Whether or not the
-destructor is called for the `std::type_info` object at the end of the
-program is unspecified.
 When `typeid` is applied to a glvalue whose type is a polymorphic class
 type [[class.virtual]], the result refers to a `std::type_info` object
 representing the type of the most derived object [[intro.object]] (that
 is, the dynamic type) to which the glvalue refers. If the glvalue is
-obtained by applying the unary `*` operator to a pointer[^16] and the
-pointer is a null pointer value [[basic.compound]], the `typeid`
 expression throws an exception [[except.throw]] of a type that would
 match a handler of type `std::bad_typeid` exception [[bad.typeid]].
 When `typeid` is applied to an expression other than a glvalue of a
 polymorphic class type, the result refers to a `std::type_info` object
 representing the static type of the expression. Lvalue-to-rvalue
 [[conv.lval]], array-to-pointer [[conv.array]], and function-to-pointer
 [[conv.func]] conversions are not applied to the expression. If the
 expression is a prvalue, the temporary materialization conversion
 [[conv.rval]] is applied. The expression is an unevaluated operand
-[[expr.prop]].
 When `typeid` is applied to a *type-id*, the result refers to a
 `std::type_info` object representing the type of the *type-id*. If the
 type of the *type-id* is a reference to a possibly cv-qualified type,
 the result of the `typeid` expression refers to a `std::type_info`
-object representing the cv-unqualified referenced type. If the type of
-the *type-id* is a class type or a reference to a class type, the class
-shall be completely-defined.
 [*Note 1*: The *type-id* cannot denote a function type with a
 *cv-qualifier-seq* or a *ref-qualifier* [[dcl.fct]]. — *end note*]
 If the type of the expression or *type-id* is a cv-qualified type, the
@@ -570,12 +619,14 @@ typeid(D)  == typeid(d2);       // yields true
 typeid(D)  == typeid(const D&); // yields true
 ```
 — *end example*]
-If the header `<typeinfo>` is not imported or included prior to a use of
-`typeid`, the program is ill-formed.
 [*Note 2*: Subclause [[class.cdtor]] describes the behavior of `typeid`
 applied to an object under construction or destruction. — *end note*]
 #### Static cast <a id="expr.static.cast">[[expr.static.cast]]</a>
@@ -611,19 +662,19 @@ B &br = d;
 static_cast<D&>(br);            // produces lvalue denoting the original d object
 ```
 — *end example*]
-An lvalue of type “*cv1* `T1`” can be cast to type “rvalue reference to
-*cv2* `T2`” if “*cv2* `T2`” is reference-compatible with “*cv1* `T1`”
-[[dcl.init.ref]]. If the value is not a bit-field, the result refers to
-the object or the specified base class subobject thereof; otherwise, the
-lvalue-to-rvalue conversion [[conv.lval]] is applied to the bit-field
-and the resulting prvalue is used as the *expression* of the
-`static_cast` for the remainder of this subclause. If `T2` is an
-inaccessible [[class.access]] or ambiguous [[class.member.lookup]] base
-class of `T1`, a program that necessitates such a cast is ill-formed.
 An expression E can be explicitly converted to a type `T` if there is an
 implicit conversion sequence [[over.best.ics]] from E to `T`, if
 overload resolution for a direct-initialization [[dcl.init]] of an
 object or reference of type `T` from E would find at least one viable
@@ -652,13 +703,16 @@ direct-initialization defines the type of the expression as
 Otherwise, the `static_cast` shall perform one of the conversions listed
 below. No other conversion shall be performed explicitly using a
 `static_cast`.
 Any expression can be explicitly converted to type cv `void`, in which
-case it becomes a discarded-value expression [[expr.prop]].
-[*Note 3*: However, if the value is in a temporary object
 [[class.temporary]], the destructor for that object is not executed
 until the usual time, and the value of the object is preserved for the
 purpose of executing the destructor. — *end note*]
 The inverse of any standard conversion sequence [[conv]] not containing
@@ -696,39 +750,48 @@ explicitly converted to a floating-point type; the result is the same as
 that of converting from the original value to the floating-point type.
 A value of integral or enumeration type can be explicitly converted to a
 complete enumeration type. If the enumeration type has a fixed
 underlying type, the value is first converted to that type by integral
-conversion, if necessary, and then to the enumeration type. If the
-enumeration type does not have a fixed underlying type, the value is
-unchanged if the original value is within the range of the enumeration
-values [[dcl.enum]], and otherwise, the behavior is undefined. A value
-of floating-point type can also be explicitly converted to an
-enumeration type. The resulting value is the same as converting the
-original value to the underlying type of the enumeration [[conv.fpint]],
-and subsequently to the enumeration type.
 A prvalue of type “pointer to *cv1* `B`”, where `B` is a class type, can
 be converted to a prvalue of type “pointer to *cv2* `D`”, where `D` is a
 complete class derived [[class.derived]] from `B`, if *cv2* is the same
 cv-qualification as, or greater cv-qualification than, *cv1*. If `B` is
 a virtual base class of `D` or a base class of a virtual base class of
 `D`, or if no valid standard conversion from “pointer to `D`” to
 “pointer to `B`” exists [[conv.ptr]], the program is ill-formed. The
 null pointer value [[basic.compound]] is converted to the null pointer
 value of the destination type. If the prvalue of type “pointer to *cv1*
-`B`” points to a `B` that is actually a subobject of an object of type
-`D`, the resulting pointer points to the enclosing object of type `D`.
-Otherwise, the behavior is undefined.
 A prvalue of type “pointer to member of `D` of type *cv1* `T`” can be
 converted to a prvalue of type “pointer to member of `B` of type *cv2*
 `T`”, where `D` is a complete class type and `B` is a base class
 [[class.derived]] of `D`, if *cv2* is the same cv-qualification as, or
 greater cv-qualification than, *cv1*.
-[*Note 4*: Function types (including those used in
 pointer-to-member-function types) are never cv-qualified
 [[dcl.fct]]. — *end note*]
 If no valid standard conversion from “pointer to member of `B` of type
 `T`” to “pointer to member of `D` of type `T`” exists [[conv.mem]], the
@@ -737,11 +800,11 @@ converted to the null member pointer value of the destination type. If
 class `B` contains the original member, or is a base or derived class of
 the class containing the original member, the resulting pointer to
 member points to the original member. Otherwise, the behavior is
 undefined.
-[*Note 5*: Although class `B` need not contain the original member, the
 dynamic type of the object with which indirection through the pointer to
 member is performed must contain the original member; see
 [[expr.mptr.oper]]. — *end note*]
 A prvalue of type “pointer to *cv1* `void`” can be converted to a
@@ -749,14 +812,13 @@ prvalue of type “pointer to *cv2* `T`”, where `T` is an object type and
 *cv2* is the same cv-qualification as, or greater cv-qualification than,
 *cv1*. If the original pointer value represents the address `A` of a
 byte in memory and `A` does not satisfy the alignment requirement of
 `T`, then the resulting pointer value is unspecified. Otherwise, if the
 original pointer value points to an object *a*, and there is an object
-*b* of type `T` (ignoring cv-qualification) that is
-pointer-interconvertible [[basic.compound]] with *a*, the result is a
-pointer to *b*. Otherwise, the pointer value is unchanged by the
-conversion.
 [*Example 3*:
 ``` cpp
 T* p1 = new T;
@@ -806,39 +868,37 @@ A value of integral type or enumeration type can be explicitly converted
 to a pointer. A pointer converted to an integer of sufficient size (if
 any such exists on the implementation) and back to the same pointer type
 will have its original value; mappings between pointers and integers are
 otherwise *implementation-defined*.
-[*Note 4*: Except as described in [[basic.stc.dynamic.safety]], the
-result of such a conversion will not be a safely-derived pointer
-value. — *end note*]
 A function pointer can be explicitly converted to a function pointer of
 a different type.
-[*Note 5*: The effect of calling a function through a pointer to a
 function type [[dcl.fct]] that is not the same as the type used in the
 definition of the function is undefined [[expr.call]]. — *end note*]
 Except that converting a prvalue of type “pointer to `T1`” to the type
 “pointer to `T2`” (where `T1` and `T2` are function types) and back to
 its original type yields the original pointer value, the result of such
 a pointer conversion is unspecified.
-[*Note 6*: See also  [[conv.ptr]] for more details of pointer
 conversions. — *end note*]
 An object pointer can be explicitly converted to an object pointer of a
-different type.[^17] When a prvalue `v` of object pointer type is
-converted to the object pointer type “pointer to cv `T`”, the result is
 `static_cast<cv T*>(static_cast<cv~void*>(v))`.
-[*Note 7*: Converting a prvalue of type “pointer to `T1`” to the type
-“pointer to `T2`” (where `T1` and `T2` are object types and where the
-alignment requirements of `T2` are no stricter than those of `T1`) and
-back to its original type yields the original pointer
-value. — *end note*]
 Converting a function pointer to an object pointer type or vice versa is
 conditionally-supported. The meaning of such a conversion is
 *implementation-defined*, except that if an implementation supports
 conversions in both directions, converting a prvalue of one type to the
@@ -846,21 +906,23 @@ other type and back, possibly with different cv-qualification, shall
 yield the original pointer value.
 The null pointer value [[basic.compound]] is converted to the null
 pointer value of the destination type.
-[*Note 8*: A null pointer constant of type `std::nullptr_t` cannot be
 converted to a pointer type, and a null pointer constant of integral
 type is not necessarily converted to a null pointer
 value. — *end note*]
 A prvalue of type “pointer to member of `X` of type `T1`” can be
 explicitly converted to a prvalue of a different type “pointer to member
 of `Y` of type `T2`” if `T1` and `T2` are both function types or both
-object types.[^18] The null member pointer value [[conv.mem]] is
-converted to the null member pointer value of the destination type. The
-result of this conversion is unspecified, except in the following cases:
 - Converting a prvalue of type “pointer to member function” to a
   different pointer-to-member-function type and back to its original
   type yields the original pointer-to-member value.
 - Converting a prvalue of type “pointer to data member of `X` of type
@@ -888,17 +950,17 @@ otherwise, the result is a prvalue and the lvalue-to-rvalue
 Conversions that can be performed explicitly using `const_cast` are
 listed below. No other conversion shall be performed explicitly using
 `const_cast`.
 [*Note 1*: Subject to the restrictions in this subclause, an expression
-may be cast to its own type using a `const_cast`
 operator. — *end note*]
 For two similar types `T1` and `T2` [[conv.qual]], a prvalue of type
 `T1` may be explicitly converted to the type `T2` using a `const_cast`
-if, considering the cv-decompositions of both types, each P¹ᵢ is the
-same as P²ᵢ for all i. The result of a `const_cast` refers to the
 original entity.
 [*Example 1*:
 ``` cpp
@@ -931,29 +993,35 @@ materialization conversion [[conv.rval]] otherwise.
 A null pointer value [[basic.compound]] is converted to the null pointer
 value of the destination type. The null member pointer value
 [[conv.mem]] is converted to the null member pointer value of the
 destination type.
-[*Note 2*: Depending on the type of the object, a write operation
-through the pointer, lvalue or pointer to data member resulting from a
-`const_cast` that casts away a const-qualifier[^20] may produce
-undefined behavior [[dcl.type.cv]]. — *end note*]
 A conversion from a type `T1` to a type `T2` *casts away constness* if
-`T1` and `T2` are different, there is a cv-decomposition [[conv.qual]]
-of `T1` yielding *n* such that `T2` has a cv-decomposition of the form
 and there is no qualification conversion that converts `T1` to
 Casting from an lvalue of type `T1` to an lvalue of type `T2` using an
 lvalue reference cast or casting from an expression of type `T1` to an
 xvalue of type `T2` using an rvalue reference cast casts away constness
 if a cast from a prvalue of type “pointer to `T1`” to the type “pointer
 to `T2`” casts away constness.
 [*Note 3*: Some conversions which involve only changes in
-cv-qualification cannot be done using `const_cast.` For instance,
 conversions between pointers to functions are not covered because such
 conversions lead to values whose use causes undefined behavior. For the
 same reasons, conversions between pointers to member functions, and in
 particular, the conversion from a pointer to a const member function to
 a pointer to a non-const member function, are not

 ### Postfix expressions <a id="expr.post">[[expr.post]]</a>
+#### General <a id="expr.post.general">[[expr.post.general]]</a>
 Postfix expressions group left-to-right.
 ``` bnf
 postfix-expression:
     primary-expression
+    postfix-expression '[' expression-listₒₚₜ ']'
     postfix-expression '(' expression-listₒₚₜ ')'
     simple-type-specifier '(' expression-listₒₚₜ ')'
     typename-specifier '(' expression-listₒₚₜ ')'
     simple-type-specifier braced-init-list
     typename-specifier braced-init-list
     postfix-expression '.' 'template'ₒₚₜ id-expression
     postfix-expression '->' 'template'ₒₚₜ id-expression
     postfix-expression '++'
+    postfix-expression '--'
     dynamic_cast '<' type-id '>' '(' expression ')'
     static_cast '<' type-id '>' '(' expression ')'
     reinterpret_cast '<' type-id '>' '(' expression ')'
     const_cast '<' type-id '>' '(' expression ')'
     typeid '(' expression ')'
 expression-list:
     initializer-list
 ```
 [*Note 1*: The `>` token following the *type-id* in a `dynamic_cast`,
+`static_cast`, `reinterpret_cast`, or `const_cast` can be the product of
+replacing a `>>` token by two consecutive `>` tokens
 [[temp.names]]. — *end note*]
 #### Subscripting <a id="expr.sub">[[expr.sub]]</a>
+A *subscript expression* is a postfix expression followed by square
+brackets containing a possibly empty, comma-separated list of
+*initializer-clause*s that constitute the arguments to the subscript
+operator. The *postfix-expression* and the initialization of the object
+parameter of any applicable subscript operator function is sequenced
+before each expression in the *expression-list* and also before any
+default argument. The initialization of a non-object parameter of a
+subscript operator function `S` [[over.sub]], including every associated
+value computation and side effect, is indeterminately sequenced with
+respect to that of any other non-object parameter of `S`.
+With the built-in subscript operator, an *expression-list* shall be
+present, consisting of a single *assignment-expression*. One of the
+expressions shall be a glvalue of type “array of `T`” or a prvalue of
+type “pointer to `T`” and the other shall be a prvalue of unscoped
+enumeration or integral type. The result is of type “`T`”. The type
+“`T`” shall be a completely-defined object type.[^11]
+The expression `E1[E2]` is identical (by definition) to `*((E1)+(E2))`,
+except that in the case of an array operand, the result is an lvalue if
+that operand is an lvalue and an xvalue otherwise.
+[*Note 1*: Despite its asymmetric appearance, subscripting is a
 commutative operation except for sequencing. See  [[expr.unary]] and
 [[expr.add]] for details of `*` and `+` and  [[dcl.array]] for details
 of array types. — *end note*]
 #### Function call <a id="expr.call">[[expr.call]]</a>
 A function call is a postfix expression followed by parentheses
 containing a possibly empty, comma-separated list of
 *initializer-clause*s which constitute the arguments to the function.
 function, the postfix expression shall either be an lvalue that refers
 to a function (in which case the function-to-pointer standard conversion
 [[conv.func]] is suppressed on the postfix expression), or have function
 pointer type.
 If the selected function is non-virtual, or if the *id-expression* in
 the class member access expression is a *qualified-id*, that function is
 called. Otherwise, its final overrider [[class.virtual]] in the dynamic
 type of the object expression is called; such a call is referred to as a
 *virtual function call*.
+[*Note 2*: The dynamic type is the type of the object referred to by
 the current value of the object expression. [[class.cdtor]] describes
 the behavior of virtual function calls when the object expression refers
 to an object under construction or destruction. — *end note*]
+[*Note 3*: If a function or member function name is used, and name
 lookup [[basic.lookup]] does not find a declaration of that name, the
 program is ill-formed. No function is implicitly declared by such a
 call. — *end note*]
 If the *postfix-expression* names a destructor or pseudo-destructor
 [[expr.prim.id.dtor]], the type of the function call expression is
 `void`; otherwise, the type of the function call expression is the
 return type of the statically chosen function (i.e., ignoring the
 `virtual` keyword), even if the type of the function actually called is
+different. If the *postfix-expression* names a pseudo-destructor (in
 which case the *postfix-expression* is a possibly-parenthesized class
 member access), the function call destroys the object of scalar type
+denoted by the object expression of the class member access
+[[expr.ref]], [[basic.life]].
+Calling a function through an expression whose function type `E` is
+different from the function type `F` of the called function’s definition
+results in undefined behavior unless the type “pointer to `F`” can be
+converted to the type “pointer to `E`” via a function pointer conversion
+[[conv.fctptr]].
+[*Note 4*: The exception applies when the expression has the type of a
+potentially-throwing function, but the called function has a
+non-throwing exception specification, and the function types are
+otherwise the same. — *end note*]
+When a function is called, each parameter [[dcl.fct]] is initialized
+[[dcl.init]], [[class.copy.ctor]] with its corresponding argument. If
+the function is an explicit object member function and there is an
+implied object argument [[over.call.func]], the list of provided
+arguments is preceded by the implied object argument for the purposes of
+this correspondence. If there is no corresponding argument, the default
+argument for the parameter is used.
 [*Example 1*:
 ``` cpp
 template<typename ...T> int f(int n = 0, T ...t);
 int x = f<int>();               // error: no argument for second function parameter
 ```
 — *end example*]
+If the function is an implicit object member function, the `this`
+parameter of the function [[expr.prim.this]] is initialized with a
+pointer to the object of the call, converted as if by an explicit type
+conversion [[expr.cast]].
 [*Note 5*: There is no access or ambiguity checking on this conversion;
 the access checking and disambiguation are done as part of the (possibly
 implicit) class member access operator. See  [[class.member.lookup]],
 [[class.access.base]], and  [[expr.ref]]. — *end note*]
 parameter occurs within the context of the calling function.
 [*Example 2*: The access of the constructor, conversion functions or
 destructor is checked at the point of call in the calling function. If a
 constructor or destructor for a function parameter throws an exception,
+the search for a handler starts in the calling function; in particular,
+if the function called has a *function-try-block* [[except.pre]] with a
+handler that can handle the exception, this handler is not
+considered. — *end example*]
 The *postfix-expression* is sequenced before each *expression* in the
 *expression-list* and any default argument. The initialization of a
 parameter, including every associated value computation and side effect,
 is indeterminately sequenced with respect to that of any other
 parameters, but these changes cannot affect the values of the arguments
 except where a parameter is of a reference type [[dcl.ref]]; if the
 reference is to a const-qualified type, `const_cast` is required to be
 used to cast away the constness in order to modify the argument’s value.
 Where a parameter is of `const` reference type a temporary object is
+introduced if needed
+[[dcl.type]], [[lex.literal]], [[lex.string]], [[dcl.array]], [[class.temporary]].
+In addition, it is possible to modify the values of non-constant objects
+through pointer parameters. — *end note*]
 A function can be declared to accept fewer arguments (by declaring
 default arguments [[dcl.fct.default]]) or more arguments (by using the
 ellipsis, `...`, or a function parameter pack [[dcl.fct]]) than the
 number of parameters in the function definition [[dcl.fct.def]].
 by a *braced-init-list* (the initializer) constructs a value of the
 specified type given the initializer. If the type is a placeholder for a
 deduced class type, it is replaced by the return type of the function
 selected by overload resolution for class template deduction
 [[over.match.class.deduct]] for the remainder of this subclause.
+Otherwise, if the type contains a placeholder type, it is replaced by
+the type determined by placeholder type deduction
+[[dcl.type.auto.deduct]].
+[*Example 1*:
+``` cpp
+struct A {};
+void f(A&);             // #1
+void f(A&&);            // #2
+A& g();
+void h() {
+  f(g());               // calls #1
+  f(A(g()));            // calls #2 with a temporary object
+  f(auto(g()));         // calls #2 with a temporary object
+}
+```
+— *end example*]
 If the initializer is a parenthesized single expression, the type
 conversion expression is equivalent to the corresponding cast expression
 [[expr.cast]]. Otherwise, if the type is cv `void` and the initializer
 is `()` or `{}` (after pack expansion, if any), the expression is a
+prvalue of type `void` that performs no initialization. Otherwise, the
+expression is a prvalue of the specified type whose result object is
+direct-initialized [[dcl.init]] with the initializer. If the initializer
+is a parenthesized optional *expression-list*, the specified type shall
+not be an array type.
 #### Class member access <a id="expr.ref">[[expr.ref]]</a>
 A postfix expression followed by a dot `.` or an arrow `->`, optionally
+followed by the keyword `template`, and then followed by an
+*id-expression*, is a postfix expression. The postfix expression before
+the dot or arrow is evaluated;[^12]
+the result of that evaluation, together with the *id-expression*,
+determines the result of the entire postfix expression.
+[*Note 1*: If the keyword `template` is used, the following unqualified
+name is considered to refer to a template [[temp.names]]. If a
+*simple-template-id* results and is followed by a `::`, the
+*id-expression* is a *qualified-id*. — *end note*]
 For the first option (dot) the first expression shall be a glvalue. For
 the second option (arrow) the first expression shall be a prvalue having
 pointer type. The expression `E1->E2` is converted to the equivalent
 form `(*(E1)).E2`; the remainder of [[expr.ref]] will address only the
 first option (dot).[^13]
 Abbreviating *postfix-expression*`.`*id-expression* as `E1.E2`, `E1` is
 called the *object expression*. If the object expression is of scalar
 type, `E2` shall name the pseudo-destructor of that same type (ignoring
+cv-qualifications) and `E1.E2` is a prvalue of type “function of ()
 returning `void`”.
+[*Note 2*: This value can only be used for a notional function call
 [[expr.prim.id.dtor]]. — *end note*]
 Otherwise, the object expression shall be of class type. The class type
 shall be complete unless the class member access appears in the
 definition of that class.
+[*Note 3*: The program is ill-formed if the result differs from that
+when the class is complete [[class.member.lookup]]. — *end note*]
+[*Note 4*:  [[basic.lookup.qual]] describes how names are looked up
 after the `.` and `->` operators. — *end note*]
 If `E2` is a bit-field, `E1.E2` is a bit-field. The type and value
 category of `E1.E2` are determined as follows. In the remainder of
 [[expr.ref]], *cq* represents either `const` or the absence of `const`
 and *vq* represents either `volatile` or the absence of `volatile`. *cv*
 represents an arbitrary set of cv-qualifiers, as defined in
 [[basic.type.qualifier]].
 If `E2` is declared to have type “reference to `T`”, then `E1.E2` is an
+lvalue of type `T`. If `E2` is a static data member, `E1.E2` designates
+the object or function to which the reference is bound, otherwise
+`E1.E2` designates the object or function to which the corresponding
+reference member of `E1` is bound. Otherwise, one of the following rules
+applies.
 - If `E2` is a static data member and the type of `E2` is `T`, then
   `E1.E2` is an lvalue; the expression designates the named member of
   the class. The type of `E1.E2` is `T`.
 - If `E2` is a non-static data member and the type of `E1` is “*cq1 vq1*
   *cq12* stand for the “union” of *cq1* and *cq2*; that is, if *cq1* or
   *cq2* is `const`, then *cq12* is `const`. If `E2` is declared to be a
   `mutable` member, then the type of `E1.E2` is “*vq12* `T`”. If `E2` is
   not declared to be a `mutable` member, then the type of `E1.E2` is
   “*cq12* *vq12* `T`”.
+- If `E2` is an overload set, function overload resolution
+  [[over.match]] is used to select the function to which `E2` refers.
+  The type of `E1.E2` is the type of `E2` and `E1.E2` refers to the
+  function referred to by `E2`.
   - If `E2` refers to a static member function, `E1.E2` is an lvalue.
   - Otherwise (when `E2` refers to a non-static member function),
     `E1.E2` is a prvalue. The expression can be used only as the
     left-hand operand of a member function call [[class.mfct]].
     \[*Note 5*: Any redundant set of parentheses surrounding the
     expression is ignored [[expr.prim.paren]]. — *end note*]
 - If `E2` is a nested type, the expression `E1.E2` is ill-formed.
 - If `E2` is a member enumerator and the type of `E2` is `T`, the
+  expression `E1.E2` is a prvalue of type `T` whose value is the value
+  of the enumerator.
+If `E2` is a non-static member, the program is ill-formed if the class
+of which `E2` is directly a member is an ambiguous base
+[[class.member.lookup]] of the naming class [[class.access.base]] of
+`E2`.
 [*Note 6*: The program is also ill-formed if the naming class is an
 ambiguous base of the class type of the object expression; see
 [[class.access.base]]. — *end note*]
+If `E2` is a non-static member and the result of `E1` is an object whose
+type is not similar [[conv.qual]] to the type of `E1`, the behavior is
+undefined.
+[*Example 1*:
+``` cpp
+struct A { int i; };
+struct B { int j; };
+struct D : A, B {};
+void f() {
+  D d;
+  static_cast<B&>(d).j;             // OK, object expression designates the B subobject of d
+  reinterpret_cast<B&>(d).j;        // undefined behavior
+}
+```
+— *end example*]
 #### Increment and decrement <a id="expr.post.incr">[[expr.post.incr]]</a>
 The value of a postfix `++` expression is the value of its operand.
 [*Note 1*: The value obtained is a copy of the original
 version of the type of the operand. If the operand is a bit-field that
 cannot represent the incremented value, the resulting value of the
 bit-field is *implementation-defined*. See also  [[expr.add]] and
 [[expr.ass]].
+The operand of postfix `--` is decremented analogously to the postfix
 `++` operator.
 [*Note 3*: For prefix increment and decrement, see
 [[expr.pre.incr]]. — *end note*]
 such that `B` is a base class of `D`, the result is a pointer to the
 unique `B` subobject of the `D` object pointed to by `v`, or a null
 pointer value if `v` is a null pointer value. Similarly, if `T` is
 “reference to *cv1* `B`” and `v` has type *cv2* `D` such that `B` is a
 base class of `D`, the result is the unique `B` subobject of the `D`
+object referred to by `v`.[^14]
+In both the pointer and reference cases, the program is ill-formed if
+`B` is an inaccessible or ambiguous base class of `D`.
 [*Example 1*:
 ``` cpp
 struct B { };
 If `T` is “pointer to cv `void`”, then the result is a pointer to the
 most derived object pointed to by `v`. Otherwise, a runtime check is
 applied to see if the object pointed or referred to by `v` can be
 converted to the type pointed or referred to by `T`.
+Let `C` be the class type to which `T` points or refers. The runtime
 check logically executes as follows:
 - If, in the most derived object pointed (referred) to by `v`, `v`
   points (refers) to a public base class subobject of a `C` object, and
   if only one object of type `C` is derived from the subobject pointed
 The result of a `typeid` expression is an lvalue of static type `const`
 `std::type_info` [[type.info]] and dynamic type `const` `std::type_info`
 or `const` *name* where *name* is an *implementation-defined* class
 publicly derived from `std::type_info` which preserves the behavior
+described in  [[type.info]].[^15]
+The lifetime of the object referred to by the lvalue extends to the end
+of the program. Whether or not the destructor is called for the
+`std::type_info` object at the end of the program is unspecified.
+If the type of the *expression* or *type-id* operand is a (possibly
+cv-qualified) class type or a reference to (possibly cv-qualified) class
+type, that class shall be completely defined.
 When `typeid` is applied to a glvalue whose type is a polymorphic class
 type [[class.virtual]], the result refers to a `std::type_info` object
 representing the type of the most derived object [[intro.object]] (that
 is, the dynamic type) to which the glvalue refers. If the glvalue is
+obtained by applying the unary `*` operator to a pointer[^16]
+and the pointer is a null pointer value [[basic.compound]], the `typeid`
 expression throws an exception [[except.throw]] of a type that would
 match a handler of type `std::bad_typeid` exception [[bad.typeid]].
 When `typeid` is applied to an expression other than a glvalue of a
 polymorphic class type, the result refers to a `std::type_info` object
 representing the static type of the expression. Lvalue-to-rvalue
 [[conv.lval]], array-to-pointer [[conv.array]], and function-to-pointer
 [[conv.func]] conversions are not applied to the expression. If the
 expression is a prvalue, the temporary materialization conversion
 [[conv.rval]] is applied. The expression is an unevaluated operand
+[[term.unevaluated.operand]].
 When `typeid` is applied to a *type-id*, the result refers to a
 `std::type_info` object representing the type of the *type-id*. If the
 type of the *type-id* is a reference to a possibly cv-qualified type,
 the result of the `typeid` expression refers to a `std::type_info`
+object representing the cv-unqualified referenced type.
 [*Note 1*: The *type-id* cannot denote a function type with a
 *cv-qualifier-seq* or a *ref-qualifier* [[dcl.fct]]. — *end note*]
 If the type of the expression or *type-id* is a cv-qualified type, the
 typeid(D)  == typeid(const D&); // yields true
 ```
 — *end example*]
+The type `std::type_info` [[type.info]] is not predefined; if a standard
+library declaration [[typeinfo.syn]], [[std.modules]] of
+`std::type_info` does not precede [[basic.lookup.general]] a `typeid`
+expression, the program is ill-formed.
 [*Note 2*: Subclause [[class.cdtor]] describes the behavior of `typeid`
 applied to an object under construction or destruction. — *end note*]
 #### Static cast <a id="expr.static.cast">[[expr.static.cast]]</a>
 static_cast<D&>(br);            // produces lvalue denoting the original d object
 ```
 — *end example*]
+An lvalue of type `T1` can be cast to type “rvalue reference to `T2`” if
+`T2` is reference-compatible with `T1` [[dcl.init.ref]]. If the value is
+not a bit-field, the result refers to the object or the specified base
+class subobject thereof; otherwise, the lvalue-to-rvalue conversion
+[[conv.lval]] is applied to the bit-field and the resulting prvalue is
+used as the operand of the `static_cast` for the remainder of this
+subclause. If `T2` is an inaccessible [[class.access]] or ambiguous
+[[class.member.lookup]] base class of `T1`, a program that necessitates
+such a cast is ill-formed.
 An expression E can be explicitly converted to a type `T` if there is an
 implicit conversion sequence [[over.best.ics]] from E to `T`, if
 overload resolution for a direct-initialization [[dcl.init]] of an
 object or reference of type `T` from E would find at least one viable
 Otherwise, the `static_cast` shall perform one of the conversions listed
 below. No other conversion shall be performed explicitly using a
 `static_cast`.
 Any expression can be explicitly converted to type cv `void`, in which
+case the operand is a discarded-value expression [[expr.prop]].
+[*Note 3*: Such a `static_cast` has no result as it is a prvalue of
+type `void`; see  [[basic.lval]]. — *end note*]
+[*Note 4*: However, if the value is in a temporary object
 [[class.temporary]], the destructor for that object is not executed
 until the usual time, and the value of the object is preserved for the
 purpose of executing the destructor. — *end note*]
 The inverse of any standard conversion sequence [[conv]] not containing
 that of converting from the original value to the floating-point type.
 A value of integral or enumeration type can be explicitly converted to a
 complete enumeration type. If the enumeration type has a fixed
 underlying type, the value is first converted to that type by integral
+promotion [[conv.prom]] or integral conversion [[conv.integral]], if
+necessary, and then to the enumeration type. If the enumeration type
+does not have a fixed underlying type, the value is unchanged if the
+original value is within the range of the enumeration values
+[[dcl.enum]], and otherwise, the behavior is undefined. A value of
+floating-point type can also be explicitly converted to an enumeration
+type. The resulting value is the same as converting the original value
+to the underlying type of the enumeration [[conv.fpint]], and
+subsequently to the enumeration type.
+A prvalue of floating-point type can be explicitly converted to any
+other floating-point type. If the source value can be exactly
+represented in the destination type, the result of the conversion has
+that exact representation. If the source value is between two adjacent
+destination values, the result of the conversion is an
+*implementation-defined* choice of either of those values. Otherwise,
+the behavior is undefined.
 A prvalue of type “pointer to *cv1* `B`”, where `B` is a class type, can
 be converted to a prvalue of type “pointer to *cv2* `D`”, where `D` is a
 complete class derived [[class.derived]] from `B`, if *cv2* is the same
 cv-qualification as, or greater cv-qualification than, *cv1*. If `B` is
 a virtual base class of `D` or a base class of a virtual base class of
 `D`, or if no valid standard conversion from “pointer to `D`” to
 “pointer to `B`” exists [[conv.ptr]], the program is ill-formed. The
 null pointer value [[basic.compound]] is converted to the null pointer
 value of the destination type. If the prvalue of type “pointer to *cv1*
+`B`” points to a `B` that is actually a base class subobject of an
+object of type `D`, the resulting pointer points to the enclosing object
+of type `D`. Otherwise, the behavior is undefined.
 A prvalue of type “pointer to member of `D` of type *cv1* `T`” can be
 converted to a prvalue of type “pointer to member of `B` of type *cv2*
 `T`”, where `D` is a complete class type and `B` is a base class
 [[class.derived]] of `D`, if *cv2* is the same cv-qualification as, or
 greater cv-qualification than, *cv1*.
+[*Note 5*: Function types (including those used in
 pointer-to-member-function types) are never cv-qualified
 [[dcl.fct]]. — *end note*]
 If no valid standard conversion from “pointer to member of `B` of type
 `T`” to “pointer to member of `D` of type `T`” exists [[conv.mem]], the
 class `B` contains the original member, or is a base or derived class of
 the class containing the original member, the resulting pointer to
 member points to the original member. Otherwise, the behavior is
 undefined.
+[*Note 6*: Although class `B` need not contain the original member, the
 dynamic type of the object with which indirection through the pointer to
 member is performed must contain the original member; see
 [[expr.mptr.oper]]. — *end note*]
 A prvalue of type “pointer to *cv1* `void`” can be converted to a
 *cv2* is the same cv-qualification as, or greater cv-qualification than,
 *cv1*. If the original pointer value represents the address `A` of a
 byte in memory and `A` does not satisfy the alignment requirement of
 `T`, then the resulting pointer value is unspecified. Otherwise, if the
 original pointer value points to an object *a*, and there is an object
+*b* of type similar to `T` that is pointer-interconvertible
+[[basic.compound]] with *a*, the result is a pointer to *b*. Otherwise,
+the pointer value is unchanged by the conversion.
 [*Example 3*:
 ``` cpp
 T* p1 = new T;
 to a pointer. A pointer converted to an integer of sufficient size (if
 any such exists on the implementation) and back to the same pointer type
 will have its original value; mappings between pointers and integers are
 otherwise *implementation-defined*.
 A function pointer can be explicitly converted to a function pointer of
 a different type.
+[*Note 4*: The effect of calling a function through a pointer to a
 function type [[dcl.fct]] that is not the same as the type used in the
 definition of the function is undefined [[expr.call]]. — *end note*]
 Except that converting a prvalue of type “pointer to `T1`” to the type
 “pointer to `T2`” (where `T1` and `T2` are function types) and back to
 its original type yields the original pointer value, the result of such
 a pointer conversion is unspecified.
+[*Note 5*: See also  [[conv.ptr]] for more details of pointer
 conversions. — *end note*]
 An object pointer can be explicitly converted to an object pointer of a
+different type.[^17]
+When a prvalue `v` of object pointer type is converted to the object
+pointer type “pointer to cv `T`”, the result is
 `static_cast<cv T*>(static_cast<cv~void*>(v))`.
+[*Note 6*: Converting a pointer of type “pointer to `T1`” that points
+to an object of type `T1` to the type “pointer to `T2`” (where `T2` is
+an object type and the alignment requirements of `T2` are no stricter
+than those of `T1`) and back to its original type yields the original
+pointer value. — *end note*]
 Converting a function pointer to an object pointer type or vice versa is
 conditionally-supported. The meaning of such a conversion is
 *implementation-defined*, except that if an implementation supports
 conversions in both directions, converting a prvalue of one type to the
 yield the original pointer value.
 The null pointer value [[basic.compound]] is converted to the null
 pointer value of the destination type.
+[*Note 7*: A null pointer constant of type `std::nullptr_t` cannot be
 converted to a pointer type, and a null pointer constant of integral
 type is not necessarily converted to a null pointer
 value. — *end note*]
 A prvalue of type “pointer to member of `X` of type `T1`” can be
 explicitly converted to a prvalue of a different type “pointer to member
 of `Y` of type `T2`” if `T1` and `T2` are both function types or both
+object types.[^18]
+The null member pointer value [[conv.mem]] is converted to the null
+member pointer value of the destination type. The result of this
+conversion is unspecified, except in the following cases:
 - Converting a prvalue of type “pointer to member function” to a
   different pointer-to-member-function type and back to its original
   type yields the original pointer-to-member value.
 - Converting a prvalue of type “pointer to data member of `X` of type
 Conversions that can be performed explicitly using `const_cast` are
 listed below. No other conversion shall be performed explicitly using
 `const_cast`.
 [*Note 1*: Subject to the restrictions in this subclause, an expression
+can be cast to its own type using a `const_cast`
 operator. — *end note*]
 For two similar types `T1` and `T2` [[conv.qual]], a prvalue of type
 `T1` may be explicitly converted to the type `T2` using a `const_cast`
+if, considering the qualification-decompositions of both types, each P¹ᵢ
+is the same as P²ᵢ for all i. The result of a `const_cast` refers to the
 original entity.
 [*Example 1*:
 ``` cpp
 A null pointer value [[basic.compound]] is converted to the null pointer
 value of the destination type. The null member pointer value
 [[conv.mem]] is converted to the null member pointer value of the
 destination type.
+[*Note 2*:
+Depending on the type of the object, a write operation through the
+pointer, lvalue or pointer to data member resulting from a `const_cast`
+that casts away a const-qualifier[^20]
+can produce undefined behavior [[dcl.type.cv]].
+— *end note*]
 A conversion from a type `T1` to a type `T2` *casts away constness* if
+`T1` and `T2` are different, there is a qualification-decomposition
+[[conv.qual]] of `T1` yielding *n* such that `T2` has a
+qualification-decomposition of the form
 and there is no qualification conversion that converts `T1` to
 Casting from an lvalue of type `T1` to an lvalue of type `T2` using an
 lvalue reference cast or casting from an expression of type `T1` to an
 xvalue of type `T2` using an rvalue reference cast casts away constness
 if a cast from a prvalue of type “pointer to `T1`” to the type “pointer
 to `T2`” casts away constness.
 [*Note 3*: Some conversions which involve only changes in
+cv-qualification cannot be done using `const_cast`. For instance,
 conversions between pointers to functions are not covered because such
 conversions lead to values whose use causes undefined behavior. For the
 same reasons, conversions between pointers to member functions, and in
 particular, the conversion from a pointer to a const member function to
 a pointer to a non-const member function, are not

Diff to HTML by rtfpessoa