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

Files changed (1) hide show

tmp/tmpj_1fm31m/{from.md → to.md} +109 -82

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

@@ -5,80 +5,100 @@ 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 a valid standard conversion from
-“pointer to `D`” to “pointer to `B`” exists ([[conv.ptr]]), *cv2* is
-the same cv-qualification as, or greater 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 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
-glvalue.
 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]]).
-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.
 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]]), or boolean (
-[[conv.bool]]) 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.
 ``` cpp
 struct B { };
 struct D : private B { };
 void f() {
-  static_cast<D*>((B*)0);               // Error: B is a private base of D.
-  static_cast<int B::*>((int D::*)0);   // Error: B is a private base of D.
 }
 ```
 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
@@ -92,60 +112,67 @@ 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 (
-[[conv.ptr]]), *cv2* is the same cv-qualification as, or greater
-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 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.
 ```

 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.
+[*Example 1*:
 ``` cpp
 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 { };
 struct D : private B { };
 void f() {
+  static_cast<D*>((B*)0);               // error: B is a private base of D
+  static_cast<int B::*>((int D::*)0);   // error: B is a private base of D
 }
 ```
+— *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
 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
+prvalue of type “pointer to *cv2* `T`”, where `T` is an object type and
 *cv2* is the same cv-qualification as, or greater cv-qualification than,
+*cv1*. If the original pointer value represents the address `A` of a
+byte in memory and `A` does not satisfy the alignment requirement of
+`T`, then the resulting pointer value is unspecified. Otherwise, if the
+original pointer value points to an object *a*, and there is an object
+*b* of type `T` (ignoring cv-qualification) that is
+pointer-interconvertible ([[basic.compound]]) with *a*, the result is a
+pointer to *b*. Otherwise, the pointer value is unchanged by the
+conversion.
+[*Example 3*:
 ``` cpp
 T* p1 = new T;
 const T* p2 = static_cast<const T*>(static_cast<void*>(p1));
 bool b = p1 == p2;  // b will have the value true.
 ```
+— *end example*]

Diff to HTML by rtfpessoa