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

Files changed (1) hide show

tmp/tmp3ojjc2m1/{from.md → to.md} +424 -413

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

@@ -1,6 +1,6 @@
-## Postfix expressions <a id="expr.post">[[expr.post]]</a>
 Postfix expressions group left-to-right.
 ``` bnf
 postfix-expression:
@@ -9,156 +9,172 @@ postfix-expression:
     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 '.' pseudo-destructor-name
-    postfix-expression '->' pseudo-destructor-name
     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 ')'
- 'typeid (' type-id ')'
 ```
 ``` bnf
 expression-list:
     initializer-list
 ```
-``` bnf
-pseudo-destructor-name:
-    nested-name-specifierₒₚₜ type-name ':: ~' type-name
-    nested-name-specifier 'template' simple-template-id ':: ~' type-name
-    '~' type-name
-    '~' decltype-specifier
-```
 [*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.[^5] The expression `E1[E2]` is identical (by definition) to
-`*((E1)+(E2))`
-[*Note 1*: see  [[expr.unary]] and  [[expr.add]] for details of `*` and
-`+` and  [[dcl.array]] for details of arrays. — *end note*]
-, 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`.
 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.
 The postfix expression shall have function type or function pointer
 type. For a call to a non-member function or to a static member
-function, the postfix expression shall be either 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
-it shall have function pointer type. 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 (
-[[dcl.link]]). 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 1*: A member function call of the form `f()` is interpreted as
 `(*this).f()` (see  [[class.mfct.non-static]]). — *end note*]
-If a function or member function name is used, the name can be
-overloaded (Clause  [[over]]), in which case the appropriate function
-shall be selected according to the rules in  [[over.match]]. 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* designates a destructor ([[class.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`.
-When a function is called, each parameter ([[dcl.fct]]) shall be
-initialized ([[dcl.init]],  [[class.copy]],  [[class.ctor]]) with its
-corresponding argument. If the function is a non-static member function,
-the `this` parameter of the function ([[class.this]]) shall be
-initialized with a pointer to the object of the call, converted as if by
-an explicit type conversion ([[expr.cast]]).
-[*Note 4*: 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*]
-When a function is called, the parameters that have object type shall
-have completely-defined object type.
-[*Note 5*: this still allows a parameter to be a pointer or reference
-to an incomplete class type. However, it prevents a passed-by-value
-parameter to have an incomplete class type. — *end note*]
 It is *implementation-defined* whether the lifetime of a parameter ends
 when the function in which it is defined returns or at the end of the
 enclosing full-expression. The initialization and destruction of each
 parameter occurs within the context of the calling function.
-[*Example 1*: 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* (Clause
-[[except]]) 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
 parameter.
-[*Note 6*: All side effects of argument evaluations are sequenced
 before the function is entered (see
 [[intro.execution]]). — *end note*]
-[*Example 2*:
 ``` cpp
 void f() {
   std::string s = "but I have heard it works even if you don't believe in it";
   s.replace(0, 4, "").replace(s.find("even"), 4, "only").replace(s.find(" don't"), 6, "");
@@ -166,15 +182,15 @@ void f() {
 }
 ```
 — *end example*]
-[*Note 7*: If an operator function is invoked using operator notation,
 argument evaluation is sequenced as specified for the built-in operator;
 see  [[over.match.oper]]. — *end note*]
-[*Example 3*:
 ``` cpp
 struct S {
   S(int);
 };
@@ -188,213 +204,202 @@ After performing the initializations, the value of `i` is 2 (see
 [[expr.shift]]), but it is unspecified whether the value of `j` is 1 or
 2.
 — *end example*]
-The result of a function call is the result of the operand of the
-evaluated `return` statement ([[stmt.return]]) in the called function
-(if any), except in a virtual function call if the return type of the
-final overrider is different from the return type of the statically
-chosen function, the value returned from the final overrider is
-converted to the return type of the statically chosen function.
-[*Note 8*:  A function can change the values of its non-const
 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]]).
-[*Note 9*: This implies that, except where the ellipsis (`...`) or a
 function parameter pack is used, a parameter is available for each
 argument. — *end note*]
 When there is no parameter for a given argument, the argument is passed
 in such a way that the receiving function can obtain the value of the
-argument by invoking `va_arg` ([[support.runtime]]).
-[*Note 10*: This paragraph does not apply to arguments passed to a
 function parameter pack. Function parameter packs are expanded during
-template instantiation ([[temp.variadic]]), thus each such argument has
-a corresponding parameter when a function template specialization is
 actually called. — *end note*]
-The lvalue-to-rvalue ([[conv.lval]]), array-to-pointer (
-[[conv.array]]), and function-to-pointer ([[conv.func]]) standard
-conversions are performed on the argument expression. An argument that
-has type cv `std::nullptr_t` is converted to type `void*` (
-[[conv.ptr]]). After these conversions, if the argument does not have
-arithmetic, enumeration, pointer, pointer to member, or class type, the
-program is ill-formed. Passing a potentially-evaluated argument of class
-type (Clause  [[class]]) having a non-trivial copy constructor, a
-non-trivial move constructor, or a non-trivial destructor, with no
-corresponding parameter, is conditionally-supported with
-*implementation-defined* semantics. If the argument has integral or
-enumeration type that is subject to the integral promotions (
-[[conv.prom]]), or a floating-point type that is subject to the
-floating-point promotion ([[conv.fpprom]]), the value of the argument
-is converted to the promoted type before the call. These promotions are
 referred to as the *default argument promotions*.
-Recursive calls are permitted, except to the `main` function (
-[[basic.start.main]]).
 A function call is an lvalue if the result type is an lvalue reference
 type or an rvalue reference to function type, an xvalue if the result
 type is an rvalue reference to object type, and a prvalue otherwise.
-### Explicit type conversion (functional notation) <a id="expr.type.conv">[[expr.type.conv]]</a>
-A *simple-type-specifier* ([[dcl.type.simple]]) or
-*typename-specifier* ([[temp.res]]) followed by a parenthesized
-optional *expression-list* or 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 section.
 If the initializer is a parenthesized single expression, the type
-conversion expression is equivalent (in definedness, and if defined in
-meaning) to the corresponding cast expression ([[expr.cast]]). If the
-type is cv `void` and the initializer is `()`, 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. For an expression of the form `T()`, `T` shall not be an
-array type.
-### Pseudo destructor call <a id="expr.pseudo">[[expr.pseudo]]</a>
-The use of a *pseudo-destructor-name* after a dot `.` or arrow `->`
-operator represents the destructor for the non-class type denoted by
-*type-name* or *decltype-specifier*. The result shall only be used as
-the operand for the function call operator `()`, and the result of such
-a call has type `void`. The only effect is the evaluation of the
-*postfix-expression* before the dot or arrow.
-The left-hand side of the dot operator shall be of scalar type. The
-left-hand side of the arrow operator shall be of pointer to scalar type.
-This scalar type is the object type. The *cv*-unqualified versions of
-the object type and of the type designated by the
-*pseudo-destructor-name* shall be the same type. Furthermore, the two
-*type-name*s in a *pseudo-destructor-name* of the form
-``` bnf
-nested-name-specifierₒₚₜ type-name ':: ~' type-name
-```
-shall designate the same scalar type (ignoring cv-qualification).
-### 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;[^6] 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
-having complete class type. For the second option (arrow) the first
-expression shall be a prvalue having pointer to complete class 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).[^7] In either case, the *id-expression* shall name a member of
-the class or of one of its base classes.
-[*Note 1*: Because the name of a class is inserted in its class scope
-(Clause  [[class]]), the name of a class is also considered a nested
-member of that class. — *end note*]
-[*Note 2*:  [[basic.lookup.classref]] describes how names are looked up
 after the `.` and `->` operators. — *end note*]
-Abbreviating *postfix-expression.id-expression* as `E1.E2`, `E1` is
-called the *object expression*. 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*
   `X`”, and the type of `E2` is “*cq2 vq2* `T`”, the expression
-  designates the named member of the object designated by the first
-  expression. If `E1` is an lvalue, then `E1.E2` is an lvalue; otherwise
-  `E1.E2` is an xvalue. Let the notation *vq12* stand for the “union” of
-  *vq1* and *vq2*; that is, if *vq1* or *vq2* is `volatile`, then *vq12*
-  is `volatile`. Similarly, let the notation *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 determine whether `E1.E2`
-  refers to a static or a non-static member function.
- - If it refers to a static member function and the type of `E2` is
-    “function of parameter-type-list returning `T`”, then `E1.E2` is an
-    lvalue; the expression designates the static member function. The
- type of `E1.E2` is the same type as that of `E2`, namely “function
-    of parameter-type-list returning `T`”.
-  - Otherwise, if `E1.E2` refers to a non-static member function and the
- type of `E2` is “function of parameter-type-list *cv*
-    *ref-qualifier*ₒₚₜ  returning `T`”, then `E1.E2` is a prvalue. The
-    expression designates a non-static member function. The expression
-    can be used only as the left-hand operand of a member function
-    call ([[class.mfct]]). \[*Note 3*: Any redundant set of parentheses
-    surrounding the expression is ignored (
-    [[expr.prim]]). — *end note*] The type of `E1.E2` is “function of
-    parameter-type-list *cv* returning `T`”.
 - 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 4*: 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
-value — *end note*]
 The operand shall be a modifiable lvalue. The type of the operand shall
 be an arithmetic type other than cv `bool`, or a pointer to a complete
-object type. The value of the operand object is modified by adding `1`
-to it. The value computation of the `++` expression is sequenced before
-the modification of the operand object. With respect to an
-indeterminately-sequenced function call, the operation of postfix `++`
-is a single evaluation.
-[*Note 2*: Therefore, a function call shall not intervene between the
 lvalue-to-rvalue conversion and the side effect associated with any
-single postfix ++ operator. — *end note*]
 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
@@ -404,40 +409,37 @@ 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*]
-### Dynamic cast <a id="expr.dynamic.cast">[[expr.dynamic.cast]]</a>
 The result of the expression `dynamic_cast<T>(v)` is the result of
 converting the expression `v` to type `T`. `T` shall be a pointer or
-reference to a complete class type, or “pointer to *cv* `void`”. The
-`dynamic_cast` operator shall not cast away constness (
-[[expr.const.cast]]).
 If `T` is a pointer type, `v` shall be a prvalue of a pointer to
 complete class type, and the result is a prvalue of type `T`. If `T` is
 an lvalue reference type, `v` shall be an lvalue of a complete class
 type, and the result is an lvalue of the type referred to by `T`. If `T`
 is an rvalue reference type, `v` shall be a glvalue having a complete
 class type, and the result is an xvalue of the type referred to by `T`.
-If the type of `v` is the same as `T`, or it is the same as `T` except
-that the class object type in `T` is more cv-qualified than the class
-object type in `v`, the result is `v` (converted if necessary).
-If the value of `v` is a null pointer value in the pointer case, the
-result is the null pointer value of type `T`.
 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`. 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`.[^8] In both the pointer and reference
-cases, the program is ill-formed if *cv2* has greater cv-qualification
-than *cv1* or if `B` is an inaccessible or ambiguous base class of `D`.
 [*Example 1*:
 ``` cpp
 struct B { };
@@ -447,37 +449,37 @@ void foo(D* dp) {
 }
 ```
 — *end example*]
-Otherwise, `v` shall be a pointer to or a glvalue of a polymorphic
-type ([[class.virtual]]).
-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 (referred) to by `v` the result points (refers) to that `C`
-  object.
-- Otherwise, if `v` points (refers) to a `public` base class subobject
- of the most derived object, and the type of the most derived object
- has a base class, of type `C`, that is unambiguous and `public`, the
-  result points (refers) to the `C` subobject of the most derived
-  object.
 - Otherwise, the runtime check *fails*.
 The value of a failed cast to pointer type is the null pointer value of
 the required result type. A failed cast to reference type throws an
-exception ([[except.throw]]) of a type that would match a handler (
-[[except.handle]]) of type `std::bad_cast` ([[bad.cast]]).
 [*Example 2*:
 ``` cpp
 class A { virtual void f(); };
@@ -498,58 +500,61 @@ class E : public D, public B { };
 class F : public E, public D { };
 void h() {
   F   f;
   A*  ap  = &f;                     // succeeds: finds unique A
   D*  dp  = dynamic_cast<D*>(ap);   // fails: yields null; f has two D subobjects
-  E*  ep  = (E*)ap;                 // ill-formed: cast from virtual base
   E*  ep1 = dynamic_cast<E*>(ap);   // succeeds
 }
 ```
 — *end example*]
-[*Note 1*: [[class.cdtor]] describes the behavior of a `dynamic_cast`
-applied to an object under construction or destruction. — *end note*]
-### Type identification <a id="expr.typeid">[[expr.typeid]]</a>
 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]].[^9] 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 expression 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 expression is obtained by applying the
-unary `*` operator to a pointer[^10] and the pointer is a null pointer
-value ([[conv.ptr]]), 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 (Clause  [[expr]]).
 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.
 If the type of the expression or *type-id* is a cv-qualified type, the
 result of the `typeid` expression refers to a `std::type_info` object
 representing the cv-unqualified type.
 [*Example 1*:
@@ -565,32 +570,32 @@ typeid(D)  == typeid(d2);       // yields true
 typeid(D)  == typeid(const D&); // yields true
 ```
 — *end example*]
-If the header `<typeinfo>` ([[type.info]]) is not included prior to a
-use of `typeid`, the program is ill-formed.
-[*Note 1*: [[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>
 The result of the expression `static_cast<T>(v)` is the result of
 converting the expression `v` to type `T`. If `T` is an lvalue reference
 type or an rvalue reference to function type, the result is an lvalue;
 if `T` is an rvalue reference to object type, the result is an xvalue;
 otherwise, the result is a prvalue. The `static_cast` operator shall not
-cast away constness ([[expr.const.cast]]).
 An lvalue of type “*cv1* `B`”, where `B` is a class type, can be cast to
-type “reference to *cv2* `D`”, where `D` is a class derived (Clause
-[[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. An xvalue of type “*cv1* `B`”
 can be cast to type “rvalue reference to *cv2* `D`” with the same
 constraints as for an lvalue of type “*cv1* `B`”. If the object of type
 “*cv1* `B`” is actually a base class subobject of an object of type `D`,
 the result refers to the enclosing object of type `D`. Otherwise, the
 behavior is undefined.
@@ -601,65 +606,70 @@ behavior is undefined.
 struct B { };
 struct D : public B { };
 D d;
 B &br = d;
-static_cast<D&>(br);            // produces lvalue to 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 section. If `T2` is an
-inaccessible (Clause  [[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`, or
-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
-function ([[over.match.viable]]). If `T` is a reference type, the
-effect is the same as performing the declaration and initialization
 ``` cpp
-T t(e);
 ```
-for some invented temporary variable `t` ([[dcl.init]]) and then using
-the temporary variable as the result of the conversion. Otherwise, the
-result object is direct-initialized from `e`.
 [*Note 1*: The conversion is ill-formed when attempting to convert an
 expression of class type to an inaccessible or ambiguous base
 class. — *end note*]
 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 (Clause  [[expr]]).
-[*Note 2*: 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 (Clause  [[conv]]) not
-containing an lvalue-to-rvalue ([[conv.lval]]), array-to-pointer (
-[[conv.array]]), function-to-pointer ([[conv.func]]), null pointer (
-[[conv.ptr]]), null member pointer ([[conv.mem]]), boolean (
-[[conv.bool]]), or function pointer ([[conv.fctptr]]) conversion, can
-be performed explicitly using `static_cast`. A program is ill-formed if
-it uses `static_cast` to perform the inverse of an ill-formed standard
-conversion sequence.
 [*Example 2*:
 ``` cpp
 struct B { };
@@ -670,63 +680,68 @@ void f() {
 }
 ```
 — *end example*]
-The lvalue-to-rvalue ([[conv.lval]]), array-to-pointer (
-[[conv.array]]), and function-to-pointer ([[conv.func]]) conversions
-are applied to the operand. Such a `static_cast` is subject to the
-restriction that the explicit conversion does not cast away constness (
-[[expr.const.cast]]), and the following additional rules for specific
-cases:
-A value of a scoped enumeration type ([[dcl.enum]]) can be explicitly
-converted to an integral type. When that type is cv `bool`, the
-resulting value is `false` if the original value is zero and `true` for
-all other values. For the remaining integral types, the value is
-unchanged if the original value can be represented by the specified
-type. Otherwise, the resulting value is unspecified. A value of a scoped
-enumeration type can also be 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. The value is unchanged if the original value
-is within the range of the enumeration values ([[dcl.enum]]).
-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
-class derived (Clause  [[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 ([[conv.ptr]]) 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 `B` is a base class (Clause  [[class.derived]]) of `D`, if
-*cv2* is the same cv-qualification as, or greater cv-qualification than,
-*cv1*.[^11] 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 program is ill-formed. The null member pointer
-value ([[conv.mem]]) is 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 3*: 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
@@ -735,11 +750,11 @@ prvalue of type “pointer to *cv2* `T`”, where `T` is an object type and
 *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*:
@@ -749,34 +764,35 @@ const T* p2 = static_cast<const T*>(static_cast<void*>(p1));
 bool b = p1 == p2;  // b will have the value true.
 ```
 — *end example*]
-### Reinterpret cast <a id="expr.reinterpret.cast">[[expr.reinterpret.cast]]</a>
 The result of the expression `reinterpret_cast<T>(v)` is the result of
 converting the expression `v` to type `T`. If `T` is an lvalue reference
 type or an rvalue reference to function type, the result is an lvalue;
 if `T` is an rvalue reference to object type, the result is an xvalue;
-otherwise, the result is a prvalue and the lvalue-to-rvalue (
-[[conv.lval]]), array-to-pointer ([[conv.array]]), and
-function-to-pointer ([[conv.func]]) standard conversions are performed
-on the expression `v`. Conversions that can be performed explicitly
-using `reinterpret_cast` are listed below. No other conversion can be
-performed explicitly using `reinterpret_cast`.
-The `reinterpret_cast` operator shall not cast away constness (
-[[expr.const.cast]]). An expression of integral, enumeration, pointer,
-or pointer-to-member type can be explicitly converted to its own type;
-such a cast yields the value of its operand.
 [*Note 1*: The mapping performed by `reinterpret_cast` might, or might
 not, produce a representation different from the original
 value. — *end note*]
 A pointer can be explicitly converted to any integral type large enough
-to hold it. The mapping function is *implementation-defined*.
 [*Note 2*: It is intended to be unsurprising to those who know the
 addressing structure of the underlying machine. — *end note*]
 A value of type `std::nullptr_t` can be converted to an integral type;
@@ -798,23 +814,23 @@ 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. — *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.[^12] 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
@@ -827,76 +843,72 @@ 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
 other type and back, possibly with different cv-qualification, shall
 yield the original pointer value.
-The null pointer value ([[conv.ptr]]) 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.[^13] 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
   `T1`” to the type “pointer to data member of `Y` of type `T2`” (where
   the alignment requirements of `T2` are no stricter than those of `T1`)
-  and back to its original type yields the original pointer to member
   value.
-A glvalue expression of type `T1` can be cast to the type “reference to
-`T2`” if an expression of type “pointer to `T1`” can be explicitly
-converted to the type “pointer to `T2`” using a `reinterpret_cast`. The
-result refers to the same object as the source glvalue, but with the
-specified type.
-[*Note 9*: That is, for lvalues, a reference cast
-`reinterpret_cast<T&>(x)` has the same effect as the conversion
-`*reinterpret_cast<T*>(&x)` with the built-in `&` and `*` operators (and
-similarly for `reinterpret_cast<T&&>(x)`). — *end note*]
-No temporary is created, no copy is made, and constructors (
-[[class.ctor]]) or conversion functions ([[class.conv]]) are not
-called.[^14]
-### Const cast <a id="expr.const.cast">[[expr.const.cast]]</a>
 The result of the expression `const_cast<T>(v)` is of type `T`. If `T`
 is an lvalue reference to object type, the result is an lvalue; if `T`
 is an rvalue reference to object type, the result is an xvalue;
-otherwise, the result is a prvalue and the lvalue-to-rvalue (
-[[conv.lval]]), array-to-pointer ([[conv.array]]), and
-function-to-pointer ([[conv.func]]) standard conversions are performed
-on the expression `v`. 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 section, 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`.
-The result of a `const_cast` refers to the original entity.
 [*Example 1*:
 ``` cpp
 typedef int *A[3];                  // array of 3 pointer to int
 typedef const int *const CA[3];     // array of 3 const pointer to const int
-CA &&r = A{}; // OK, reference binds to temporary array object after qualification conversion to type CA
 A &&r1 = const_cast<A>(CA{});       // error: temporary array decayed to pointer
 A &&r2 = const_cast<A&&>(CA{});     // OK
 ```
 — *end example*]
@@ -912,26 +924,25 @@ then the following conversions can also be made:
 - if `T1` is a class type, a prvalue of type `T1` can be explicitly
   converted to an xvalue of type `T2` using the cast `const_cast<T2&&>`.
 The result of a reference `const_cast` refers to the original object if
 the operand is a glvalue and to the result of applying the temporary
-materialization conversion ([[conv.rval]]) otherwise.
-A null pointer value ([[conv.ptr]]) 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[^15] 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

+### Postfix expressions <a id="expr.post">[[expr.post]]</a>
 Postfix expressions group left-to-right.
 ``` bnf
 postfix-expression:
     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 ')'
+    typeid '(' type-id ')'
 ```
 ``` bnf
 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.
+[*Note 1*: If the postfix expression is a function or member function
+name, the appropriate function and the validity of the call are
+determined according to the rules in  [[over.match]]. — *end note*]
 The postfix expression shall have function type or function pointer
 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*]
+When a function is called, the type of any parameter shall not be a
+class type that is either incomplete or abstract.
+[*Note 6*: This still allows a parameter to be a pointer or reference
+to such a type. However, it prevents a passed-by-value parameter to have
+an incomplete or abstract class type. — *end note*]
 It is *implementation-defined* whether the lifetime of a parameter ends
 when the function in which it is defined returns or at the end of the
 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
 parameter.
+[*Note 7*: All side effects of argument evaluations are sequenced
 before the function is entered (see
 [[intro.execution]]). — *end note*]
+[*Example 3*:
 ``` cpp
 void f() {
   std::string s = "but I have heard it works even if you don't believe in it";
   s.replace(0, 4, "").replace(s.find("even"), 4, "only").replace(s.find(" don't"), 6, "");
 }
 ```
 — *end example*]
+[*Note 8*: If an operator function is invoked using operator notation,
 argument evaluation is sequenced as specified for the built-in operator;
 see  [[over.match.oper]]. — *end note*]
+[*Example 4*:
 ``` cpp
 struct S {
   S(int);
 };
 [[expr.shift]]), but it is unspecified whether the value of `j` is 1 or
 2.
 — *end example*]
+The result of a function call is the result of the possibly-converted
+operand of the `return` statement [[stmt.return]] that transferred
+control out of the called function (if any), except in a virtual
+function call if the return type of the final overrider is different
+from the return type of the statically chosen function, the value
+returned from the final overrider is converted to the return type of the
+statically chosen function.
+[*Note 9*:  A function can change the values of its non-const
 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]].
+[*Note 10*: This implies that, except where the ellipsis (`...`) or a
 function parameter pack is used, a parameter is available for each
 argument. — *end note*]
 When there is no parameter for a given argument, the argument is passed
 in such a way that the receiving function can obtain the value of the
+argument by invoking `va_arg` [[support.runtime]].
+[*Note 11*: This paragraph does not apply to arguments passed to a
 function parameter pack. Function parameter packs are expanded during
+template instantiation [[temp.variadic]], thus each such argument has a
+corresponding parameter when a function template specialization is
 actually called. — *end note*]
+The lvalue-to-rvalue [[conv.lval]], array-to-pointer [[conv.array]], and
+function-to-pointer [[conv.func]] standard conversions are performed on
+the argument expression. An argument that has type cv `std::nullptr_t`
+is converted to type `void*` [[conv.ptr]]. After these conversions, if
+the argument does not have arithmetic, enumeration, pointer,
+pointer-to-member, or class type, the program is ill-formed. Passing a
+potentially-evaluated argument of a scoped enumeration type or of a
+class type [[class]] having an eligible non-trivial copy constructor, an
+eligible non-trivial move constructor, or a non-trivial destructor
+[[special]], with no corresponding parameter, is conditionally-supported
+with *implementation-defined* semantics. If the argument has integral or
+enumeration type that is subject to the integral promotions
+[[conv.prom]], or a floating-point type that is subject to the
+floating-point promotion [[conv.fpprom]], the value of the argument is
+converted to the promoted type before the call. These promotions are
 referred to as the *default argument promotions*.
+Recursive calls are permitted, except to the `main` function
+[[basic.start.main]].
 A function call is an lvalue if the result type is an lvalue reference
 type or an rvalue reference to function type, an xvalue if the result
 type is an rvalue reference to object type, and a prvalue otherwise.
+#### Explicit type conversion (functional notation) <a id="expr.type.conv">[[expr.type.conv]]</a>
+A *simple-type-specifier* [[dcl.type.simple]] or *typename-specifier*
+[[temp.res]] followed by a parenthesized optional *expression-list* or
+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*
   `X`”, and the type of `E2` is “*cq2 vq2* `T`”, the expression
+  designates the corresponding member subobject of the object designated
+ by the first expression. If `E1` is an lvalue, then `E1.E2` is an
+ lvalue; otherwise `E1.E2` is an xvalue. Let the notation *vq12* stand
+ for the “union” of *vq1* and *vq2*; that is, if *vq1* or *vq2* is
+ `volatile`, then *vq12* is `volatile`. Similarly, let the notation
+ *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
+value. — *end note*]
 The operand shall be a modifiable lvalue. The type of the operand shall
 be an arithmetic type other than cv `bool`, or a pointer to a complete
+object type. An operand with volatile-qualified type is deprecated; see
+[[depr.volatile.type]]. The value of the operand object is modified
+[[defns.access]] by adding `1` to it. The value computation of the `++`
+expression is sequenced before the modification of the operand object.
+With respect to an indeterminately-sequenced function call, the
+operation of postfix `++` is a single evaluation.
+[*Note 2*: Therefore, a function call cannot intervene between the
 lvalue-to-rvalue conversion and the side effect associated with any
+single postfix `++` operator. — *end note*]
 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
 `++` operator.
 [*Note 3*: For prefix increment and decrement, see
 [[expr.pre.incr]]. — *end note*]
+#### Dynamic cast <a id="expr.dynamic.cast">[[expr.dynamic.cast]]</a>
 The result of the expression `dynamic_cast<T>(v)` is the result of
 converting the expression `v` to type `T`. `T` shall be a pointer or
+reference to a complete class type, or “pointer to cv `void`”. The
+`dynamic_cast` operator shall not cast away constness
+[[expr.const.cast]].
 If `T` is a pointer type, `v` shall be a prvalue of a pointer to
 complete class type, and the result is a prvalue of type `T`. If `T` is
 an lvalue reference type, `v` shall be an lvalue of a complete class
 type, and the result is an lvalue of the type referred to by `T`. If `T`
 is an rvalue reference type, `v` shall be a glvalue having a complete
 class type, and the result is an xvalue of the type referred to by `T`.
+If the type of `v` is the same as `T` (ignoring cv-qualifications), the
+result is `v` (converted if necessary).
 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 { };
 }
 ```
 — *end example*]
+Otherwise, `v` shall be a pointer to or a glvalue of a polymorphic type
+[[class.virtual]].
+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
+  (referred) to by `v` the result points (refers) to that `C` object.
+- Otherwise, if `v` points (refers) to a public base class subobject of
+  the most derived object, and the type of the most derived object has a
+ base class, of type `C`, that is unambiguous and public, the result
+ points (refers) to the `C` subobject of the most derived object.
 - Otherwise, the runtime check *fails*.
 The value of a failed cast to pointer type is the null pointer value of
 the required result type. A failed cast to reference type throws an
+exception [[except.throw]] of a type that would match a handler
+[[except.handle]] of type `std::bad_cast` [[bad.cast]].
 [*Example 2*:
 ``` cpp
 class A { virtual void f(); };
 class F : public E, public D { };
 void h() {
   F   f;
   A*  ap  = &f;                     // succeeds: finds unique A
   D*  dp  = dynamic_cast<D*>(ap);   // fails: yields null; f has two D subobjects
+  E*  ep  = (E*)ap;                 // error: cast from virtual base
   E*  ep1 = dynamic_cast<E*>(ap);   // succeeds
 }
 ```
 — *end example*]
+[*Note 1*: Subclause [[class.cdtor]] describes the behavior of a
+`dynamic_cast` applied to an object under construction or
+destruction. — *end note*]
+#### Type identification <a id="expr.typeid">[[expr.typeid]]</a>
 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
 result of the `typeid` expression refers to a `std::type_info` object
 representing the cv-unqualified type.
 [*Example 1*:
 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>
 The result of the expression `static_cast<T>(v)` is the result of
 converting the expression `v` to type `T`. If `T` is an lvalue reference
 type or an rvalue reference to function type, the result is an lvalue;
 if `T` is an rvalue reference to object type, the result is an xvalue;
 otherwise, the result is a prvalue. The `static_cast` operator shall not
+cast away constness [[expr.const.cast]].
 An lvalue of type “*cv1* `B`”, where `B` is a class type, can be cast to
+type “reference to *cv2* `D`”, where `D` is a 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. An xvalue of type “*cv1* `B`”
 can be cast to type “rvalue reference to *cv2* `D`” with the same
 constraints as for an lvalue of type “*cv1* `B`”. If the object of type
 “*cv1* `B`” is actually a base class subobject of an object of type `D`,
 the result refers to the enclosing object of type `D`. Otherwise, the
 behavior is undefined.
 struct B { };
 struct D : public B { };
 D d;
 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
+function [[over.match.viable]], or if `T` is an aggregate type
+[[dcl.init.aggr]] having a first element `x` and there is an implicit
+conversion sequence from E to the type of `x`. If `T` is a reference
+type, the effect is the same as performing the declaration and
+initialization
 ``` cpp
+T t(E);
 ```
+for some invented temporary variable `t` [[dcl.init]] and then using the
+temporary variable as the result of the conversion. Otherwise, the
+result object is direct-initialized from E.
 [*Note 1*: The conversion is ill-formed when attempting to convert an
 expression of class type to an inaccessible or ambiguous base
 class. — *end note*]
+[*Note 2*: If `T` is “array of unknown bound of `U`”, this
+direct-initialization defines the type of the expression as
+`U[1]`. — *end note*]
 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
+an lvalue-to-rvalue [[conv.lval]], array-to-pointer [[conv.array]],
+function-to-pointer [[conv.func]], null pointer [[conv.ptr]], null
+member pointer [[conv.mem]], boolean [[conv.bool]], or function pointer
+[[conv.fctptr]] conversion, can be performed explicitly using
+`static_cast`. A program is ill-formed if it uses `static_cast` to
+perform the inverse of an ill-formed standard conversion sequence.
 [*Example 2*:
 ``` cpp
 struct B { };
 }
 ```
 — *end example*]
+The lvalue-to-rvalue [[conv.lval]], array-to-pointer [[conv.array]], and
+function-to-pointer [[conv.func]] conversions are applied to the
+operand. Such a `static_cast` is subject to the restriction that the
+explicit conversion does not cast away constness [[expr.const.cast]],
+and the following additional rules for specific cases:
+A value of a scoped enumeration type [[dcl.enum]] can be explicitly
+converted to an integral type; the result is the same as that of
+converting to the enumeration’s underlying type and then to the
+destination type. A value of a scoped enumeration type can also be
+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
+program is ill-formed. The null member pointer value [[conv.mem]] is
+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
 *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*:
 bool b = p1 == p2;  // b will have the value true.
 ```
 — *end example*]
+#### Reinterpret cast <a id="expr.reinterpret.cast">[[expr.reinterpret.cast]]</a>
 The result of the expression `reinterpret_cast<T>(v)` is the result of
 converting the expression `v` to type `T`. If `T` is an lvalue reference
 type or an rvalue reference to function type, the result is an lvalue;
 if `T` is an rvalue reference to object type, the result is an xvalue;
+otherwise, the result is a prvalue and the lvalue-to-rvalue
+[[conv.lval]], array-to-pointer [[conv.array]], and function-to-pointer
+[[conv.func]] standard conversions are performed on the expression `v`.
+Conversions that can be performed explicitly using `reinterpret_cast`
+are listed below. No other conversion can be performed explicitly using
+`reinterpret_cast`.
+The `reinterpret_cast` operator shall not cast away constness
+[[expr.const.cast]]. An expression of integral, enumeration, pointer, or
+pointer-to-member type can be explicitly converted to its own type; such
+a cast yields the value of its operand.
 [*Note 1*: The mapping performed by `reinterpret_cast` might, or might
 not, produce a representation different from the original
 value. — *end note*]
 A pointer can be explicitly converted to any integral type large enough
+to hold all values of its type. The mapping function is
+*implementation-defined*.
 [*Note 2*: It is intended to be unsurprising to those who know the
 addressing structure of the underlying machine. — *end note*]
 A value of type `std::nullptr_t` can be converted to an integral type;
 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
 *implementation-defined*, except that if an implementation supports
 conversions in both directions, converting a prvalue of one type to the
 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
   `T1`” to the type “pointer to data member of `Y` of type `T2`” (where
   the alignment requirements of `T2` are no stricter than those of `T1`)
+  and back to its original type yields the original pointer-to-member
   value.
+A glvalue of type `T1`, designating an object *x*, can be cast to the
+type “reference to `T2`” if an expression of type “pointer to `T1`” can
+be explicitly converted to the type “pointer to `T2`” using a
+`reinterpret_cast`. The result is that of `*reinterpret_cast<T2 *>(p)`
+where `p` is a pointer to *x* of type “pointer to `T1`”. No temporary is
+created, no copy is made, and no constructors [[class.ctor]] or
+conversion functions [[class.conv]] are called. [^19]
+#### Const cast <a id="expr.const.cast">[[expr.const.cast]]</a>
 The result of the expression `const_cast<T>(v)` is of type `T`. If `T`
 is an lvalue reference to object type, the result is an lvalue; if `T`
 is an rvalue reference to object type, the result is an xvalue;
+otherwise, the result is a prvalue and the lvalue-to-rvalue
+[[conv.lval]], array-to-pointer [[conv.array]], and function-to-pointer
+[[conv.func]] standard conversions are performed on the expression `v`.
+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
 typedef int *A[3];                  // array of 3 pointer to int
 typedef const int *const CA[3];     // array of 3 const pointer to const int
+CA &&r = A{}; // OK, reference binds to temporary array object
+                                    // after qualification conversion to type CA
 A &&r1 = const_cast<A>(CA{});       // error: temporary array decayed to pointer
 A &&r2 = const_cast<A&&>(CA{});     // OK
 ```
 — *end example*]
 - if `T1` is a class type, a prvalue of type `T1` can be explicitly
   converted to an xvalue of type `T2` using the cast `const_cast<T2&&>`.
 The result of a reference `const_cast` refers to the original object if
 the operand is a glvalue and to the result of applying the temporary
+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

Diff to HTML by rtfpessoa