[expr.static.cast] - C++11 → C++14

Files changed (1) hide show

tmp/tmp8ggxh04x/{from.md → to.md} +36 -25

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

@@ -16,30 +16,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
@@ -79,24 +83,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 (
@@ -105,34 +112,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.

 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.

Diff to HTML by rtfpessoa