[expr.reinterpret.cast] - C++17 → C++20

Files changed (1) hide show

tmp/tmp33mny7_p/{from.md → to.md} +31 -37

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

@@ -1,29 +1,30 @@
-### 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;
@@ -45,23 +46,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
@@ -74,44 +75,37 @@ 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]

+#### 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]

Diff to HTML by rtfpessoa