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

Files changed (1) hide show

tmp/tmp_ov6ec_3/{from.md → to.md} +125 -112

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

@@ -44,64 +44,67 @@ The `>` token following the in a `dynamic_cast`, `static_cast`,
 `>{>}` token by two consecutive `>` tokens ([[temp.names]]).
 ### 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 have the type “pointer
-to `T`” and the other shall have unscoped enumeration or integral type.
-The result is an lvalue 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))` see  [[expr.unary]] and  [[expr.add]]
-for details of `*` and `+` and  [[dcl.array]] for details of arrays.
 A *braced-init-list* shall not be used with the built-in subscript
 operator.
 ### Function call <a id="expr.call">[[expr.call]]</a>
-There are two kinds of function call: ordinary function call and member
-function[^6] ([[class.mfct]]) call. A function call is a postfix
-expression followed by parentheses containing a possibly empty,
-comma-separated list of expressions which constitute the arguments to
-the function. For an ordinary function call, 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 pointer to function type.
-Calling a function through an expression whose function type has a
-language linkage that is different from the language linkage of the
-function type of the called function’s definition is undefined (
-[[dcl.link]]). For a member function call, 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`. a member function call of the form `f()` is interpreted as
-`(*this).f()` (see  [[class.mfct.non-static]]). 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. 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.
 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.
 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 type shall be an
-object type, a reference type or the type `void`.
 When a function is called, each parameter ([[dcl.fct]]) shall be
 initialized ([[dcl.init]],  [[class.copy]],  [[class.ctor]]) with its
 corresponding argument. Such initializations are indeterminately
 sequenced with respect to each other ([[intro.execution]]) If the
@@ -174,16 +177,16 @@ 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*.
-The evaluations of the postfix expression and of the argument
-expressions are all unsequenced relative to one another. All side
-effects of argument expression evaluations are sequenced before the
-function is entered (see  [[intro.execution]]).
-Recursive calls are permitted, except to the function named `main` (
 [[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.
@@ -223,14 +226,15 @@ temporary variable `t`, with the result being the value of `t` as a
 prvalue.
 The expression `T()`, where `T` is a *simple-type-specifier* or
 *typename-specifier* for a non-array complete object type or the
 (possibly cv-qualified) `void` type, creates a prvalue of the specified
-type,which is value-initialized ([[dcl.init]]; no initialization is
-done for the `void()` case). if `T` is a non-class type that is
-cv-qualified, the *cv-qualifier*s are ignored when determining the type
-of the resulting prvalue ([[basic.lval]]).
 Similarly, a *simple-type-specifier* or *typename-specifier* followed by
 a *braced-init-list* creates a temporary object of the specified type
 direct-list-initialized ([[dcl.init.list]]) with the specified
 *braced-init-list*, and its value is that temporary object as a prvalue.
@@ -260,19 +264,19 @@ shall designate the same scalar 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;[^7] 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 have complete
 class type. For the second option (arrow) the first expression shall
 have 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).[^8] In either
 case, the *id-expression* shall name a member of the class or of one of
 its base classes. 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. [[basic.lookup.classref]] describes how
 names are looked up after the `.` and `->` operators.
@@ -292,19 +296,19 @@ rules applies.
   `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; if `E1`
- is an xvalue, then `E1.E2` is an xvalue; otherwise, it is a prvalue.
- 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
@@ -377,11 +381,11 @@ 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`. [^9] The result is an lvalue if `T` is an
 lvalue reference, or an xvalue if `T` is an rvalue reference. 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`.
@@ -391,11 +395,11 @@ struct D : B { };
 void foo(D* dp) {
   B*  bp = dynamic_cast<B*>(dp);    // equivalent to B* bp = dp;
 }
 ```
-Otherwise, `v` shall be a pointer to or an lvalue 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 run-time check is
 applied to see if the object pointed or referred to by `v` can be
@@ -415,12 +419,13 @@ check logically executes as follows:
   result points (refers) to the `C` subobject of the most derived
   object.
 - Otherwise, the run-time 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
-`std::bad_cast` ([[bad.cast]]).
 ``` cpp
 class A { virtual void f(); };
 class B { virtual void g(); };
 class D : public virtual A, private B { };
@@ -454,22 +459,23 @@ object under construction or destruction.
 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]].[^10] 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[^11] and the pointer is a null pointer
-value ([[conv.ptr]]), the `typeid` expression throws the
 `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 (
@@ -485,12 +491,13 @@ 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.
-The top-level cv-qualifiers of the glvalue expression or the *type-id*
-that is the operand of `typeid` are always ignored.
 ``` cpp
 class D { /* ... */ };
 D d1;
 const D d2;
@@ -525,30 +532,34 @@ and `B` is neither a virtual base class of `D` nor a base class of a
 virtual base class of `D`. The result has type “*cv2* `D`.” An xvalue of
 type “*cv1* `B`” may 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 subobject of an object of type
 `D`, the result refers to the enclosing object of type `D`. Otherwise,
-the result of the cast is undefined.
 ``` cpp
 struct B { };
 struct D : public B { };
 D d;
 B &br = d;
 static_cast<D&>(br);            // produces lvalue to the original d object
 ```
-A glvalue 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]]). The result refers to the object or the specified base
-class subobject thereof. 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.
-Otherwise, an expression `e` can be explicitly converted to a type `T`
-using a `static_cast` of the form `static_cast<T>(e)` if the declaration
 `T t(e);` is well-formed, for some invented temporary variable `t` (
 [[dcl.init]]). The effect of such an explicit conversion is the same as
 performing the declaration and initialization and then using the
 temporary variable as the result of the conversion. The expression `e`
 is used as a glvalue if and only if the initialization uses it as a
@@ -588,24 +599,27 @@ 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 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
 an enumeration type. The value is unchanged if the original value is
 within the range of the enumeration values ([[dcl.enum]]). Otherwise,
 the resulting value is unspecified (and might not be in that range). A
-value of floating-point type can also be 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 a valid standard
 conversion from “pointer to `D`” to “pointer to `B`” exists (
@@ -614,34 +628,38 @@ cv-qualification than, *cv1*, and `B` is neither a virtual base class of
 `D` nor a base class of a virtual base class of `D`. 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 result of the cast 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 a
 valid standard conversion from “pointer to member of `B` of type `T`” to
 “pointer to member of `D` of type `T`” exists ([[conv.mem]]), and *cv2*
 is the same cv-qualification as, or greater cv-qualification than,
-*cv1*.[^12] 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 result of the cast is undefined.
-although class `B` need not contain the original member, the dynamic
-type of the object on which the pointer to member is dereferenced must
-contain the original member; see  [[expr.mptr.oper]].
 A prvalue of type “pointer to *cv1* `void`” can be converted to a
 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*. The null pointer value is converted to the null pointer value of
-the destination type. A value of type pointer to object converted to
-“pointer to *cv* `void`” and back, possibly with different
-cv-qualification, shall have its original value.
 ``` cpp
 T* p1 = new T;
 const T* p2 = static_cast<const T*>(static_cast<void*>(p1));
 bool b = p1 == p2;  // b will have the value true.
@@ -694,20 +712,17 @@ prvalue of type “pointer to `T1`” to the type “pointer to `T2`” (where
 the original pointer value, the result of such a pointer conversion is
 unspecified. see also  [[conv.ptr]] for more details of pointer
 conversions.
 An object pointer can be explicitly converted to an object pointer of a
-different type.[^13] When a prvalue `v` of type “pointer to `T1`” is
-converted to the type “pointer to cv `T2`”, the result is
-`static_cast<cv T2*>(static_cast<cv void*>(v))` if both `T1` and `T2`
-are standard-layout types ([[basic.types]]) and the alignment
-requirements of `T2` are no stricter than those of `T1`, or if either
-type is `void`. 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. The
-result of any other such pointer conversion is unspecified.
 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
@@ -721,11 +736,11 @@ pointer constant of integral type is not necessarily converted to a null
 pointer value.
 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.[^14] 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
@@ -734,22 +749,20 @@ result of this conversion is unspecified, except in the following cases:
   `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.
-An lvalue 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`. That
-is, 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)`). The result
-refers to the same object as the source lvalue, but with a different
-type. The result is an lvalue for an lvalue reference type or an rvalue
-reference to function type and an xvalue for an rvalue reference to
-object type. No temporary is created, no copy is made, and
-constructors ([[class.ctor]]) or conversion functions ([[class.conv]])
-are not called.[^15]
 ### 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`
@@ -801,11 +814,11 @@ value of the destination type. The null member pointer value (
 [[conv.mem]]) is converted to the null member pointer value of the
 destination type.
 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[^16] may produce undefined behavior (
 [[dcl.type.cv]]).
 The following rules define the process known as *casting away
 constness*. In these rules `Tn ` and `Xn ` represent types. For two
 pointer types:

 `>{>}` token by two consecutive `>` tokens ([[temp.names]]).
 ### 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 have the type “array of
+`T`” or “pointer to `T`” and the other shall have 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))` see  [[expr.unary]] and  [[expr.add]]
+for details of `*` and `+` and  [[dcl.array]] for details of arrays. ,
+except that in the case of an array operand, the result is an lvalue if
+that operand is an lvalue and an xvalue otherwise.
 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 pointer to function
+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 pointer to function type. Calling a function through an
+expression whose function type has a language linkage that is different
+from the language linkage of the function type of the called function’s
+definition is undefined ([[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`. a member
+function call of the form `f()` is interpreted as `(*this).f()` (see
+[[class.mfct.non-static]]). 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*. 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.
 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.
 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. Such initializations are indeterminately
 sequenced with respect to each other ([[intro.execution]]) If the
 [[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*.
+The evaluations of the postfix expression and of the arguments are all
+unsequenced relative to one another. All side effects of argument
+evaluations are sequenced before the function is entered (see
+[[intro.execution]]).
+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.
 prvalue.
 The expression `T()`, where `T` is a *simple-type-specifier* or
 *typename-specifier* for a non-array complete object type or the
 (possibly cv-qualified) `void` type, creates a prvalue of the specified
+type, whose value is that produced by value-initializing ([[dcl.init]])
+an object of type `T`; no initialization is done for the `void()` case.
+if `T` is a non-class type that is cv-qualified, the *cv-qualifier*s are
+discarded when determining the type of the resulting prvalue (Clause
+[[expr]]).
 Similarly, a *simple-type-specifier* or *typename-specifier* followed by
 a *braced-init-list* creates a temporary object of the specified type
 direct-list-initialized ([[dcl.init.list]]) with the specified
 *braced-init-list*, and its value is that temporary object as a prvalue.
 ### 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 have complete
 class type. For the second option (arrow) the first expression shall
 have 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. 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. [[basic.lookup.classref]] describes how
 names are looked up after the `.` and `->` operators.
   `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
 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] The result is an lvalue if `T` is an
 lvalue reference, or an xvalue if `T` is an rvalue reference. 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`.
 void foo(D* dp) {
   B*  bp = dynamic_cast<B*>(dp);    // equivalent to B* bp = dp;
 }
 ```
+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 run-time check is
 applied to see if the object pointed or referred to by `v` can be
   result points (refers) to the `C` subobject of the most derived
   object.
 - Otherwise, the run-time 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]]).
 ``` cpp
 class A { virtual void f(); };
 class B { virtual void g(); };
 class D : public virtual A, private B { };
 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 (
 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.
 ``` cpp
 class D { /* ... */ };
 D d1;
 const D d2;
 virtual base class of `D`. The result has type “*cv2* `D`.” An xvalue of
 type “*cv1* `B`” may 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 subobject of an object of type
 `D`, the result refers to the enclosing object of type `D`. Otherwise,
+the behavior is undefined.
 ``` cpp
 struct B { };
 struct D : public B { };
 D d;
 B &br = d;
 static_cast<D&>(br);            // produces lvalue to the original d object
 ```
+A glvalue, class prvalue, or array prvalue 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` using a
+`static_cast` of the form `static_cast<T>(e)` if the declaration
 `T t(e);` is well-formed, for some invented temporary variable `t` (
 [[dcl.init]]). The effect of such an explicit conversion is the same as
 performing the declaration and initialization and then using the
 temporary variable as the result of the conversion. The expression `e`
 is used as a glvalue if and only if the initialization uses it as a
 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
 an enumeration type. The value is unchanged if the original value is
 within the range of the enumeration values ([[dcl.enum]]). Otherwise,
 the resulting value is unspecified (and might not be in that range). 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 a valid standard
 conversion from “pointer to `D`” to “pointer to `B`” exists (
 `D` nor a base class of a virtual base class of `D`. 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 a
 valid standard conversion from “pointer to member of `B` of type `T`” to
 “pointer to member of `D` of type `T`” exists ([[conv.mem]]), and *cv2*
 is the same cv-qualification as, or greater cv-qualification than,
+*cv1*.[^11] 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. 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]].
 A prvalue of type “pointer to *cv1* `void`” can be converted to a
 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*. The null pointer value is converted to the null pointer value of
+the destination type. If the original pointer value represents the
+address `A` of a byte in memory and `A` satisfies the alignment
+requirement of `T`, then the resulting pointer value represents the same
+address as the original pointer value, that is, `A`. The result of any
+other such pointer conversion is unspecified. A value of type pointer to
+object converted to “pointer to *cv* `void`” and back, possibly with
+different cv-qualification, shall have its original value.
 ``` cpp
 T* p1 = new T;
 const T* p2 = static_cast<const T*>(static_cast<void*>(p1));
 bool b = p1 == p2;  // b will have the value true.
 the original pointer value, the result of such a pointer conversion is
 unspecified. see also  [[conv.ptr]] for more details of pointer
 conversions.
 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))`. 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.
 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
 pointer value.
 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
   `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. 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)`). 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`
 [[conv.mem]]) is converted to the null member pointer value of the
 destination type.
 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]]).
 The following rules define the process known as *casting away
 constness*. In these rules `Tn ` and `Xn ` represent types. For two
 pointer types:

Diff to HTML by rtfpessoa