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

Files changed (1) hide show

tmp/tmp3h02oe5m/{from.md → to.md} +37 -48

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

@@ -8,22 +8,30 @@ otherwise, the result is a prvalue and the lvalue-to-rvalue (
 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`.
-Subject to the restrictions in this section, an expression may be cast
-to its own type using a `const_cast` operator.
-For two pointer types `T1` and `T2` where
-and
-where `T` is any object type or the `void` type and where
-$\mathit{cv}_{1,k}$ and $\mathit{cv}_{2,k}$ may be different
-cv-qualifications, a prvalue of type `T1` may be explicitly converted to
-the type `T2` using a `const_cast`. The result of a pointer `const_cast`
-refers to the original object.
 For two object types `T1` and `T2`, if a pointer to `T1` can be
 explicitly converted to the type “pointer to `T2`” using a `const_cast`,
 then the following conversions can also be made:
@@ -32,60 +40,41 @@ then the following conversions can also be made:
 - a glvalue of type `T1` can be explicitly converted to an xvalue of
   type `T2` using the cast `const_cast<T2&&>`; and
 - 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.
-For a `const_cast` involving pointers to data members, multi-level
-pointers to data members and multi-level mixed pointers and pointers to
-data members ([[conv.qual]]), the rules for `const_cast` are the same
-as those used for pointers; the “member” aspect of a pointer to member
-is ignored when determining where the cv-qualifiers are added or removed
-by the `const_cast`. The result of a pointer to data member `const_cast`
-refers to the same member as the original (uncast) pointer to data
-member.
 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.
-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:
-casting from `X1` to `X2` casts away constness if, for a non-pointer
-type `T` there does not exist an implicit conversion (Clause  [[conv]])
-from:
-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
 xvalue of type `T2` using an rvalue reference cast casts away constness
 if a cast from a prvalue of type “pointer to `T1`” to the type “pointer
 to `T2`” casts away constness.
-Casting from 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`” casts
-away constness if a cast from a prvalue of type “pointer to `T1`” to the
-type “pointer to `T2`” casts away constness.
-For multi-level pointer to members and multi-level mixed pointers and
-pointer to members ([[conv.qual]]), the “member” aspect of a pointer to
-member level is ignored when determining if a `const` cv-qualifier has
-been cast away.
-some conversions which involve only changes in cv-qualification cannot
-be done using `const_cast.` For instance, conversions between pointers
-to functions are not covered because such conversions lead to values
-whose use causes undefined behavior. For the same reasons, conversions
-between pointers to member functions, and in particular, the conversion
-from a pointer to a const member function to a pointer to a non-const
-member function, are not covered.

 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*]
 For two object types `T1` and `T2`, if a pointer to `T1` can be
 explicitly converted to the type “pointer to `T2`” using a `const_cast`,
 then the following conversions can also be made:
 - a glvalue of type `T1` can be explicitly converted to an xvalue of
   type `T2` using the cast `const_cast<T2&&>`; and
 - 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
 xvalue of type `T2` using an rvalue reference cast casts away constness
 if a cast from a prvalue of type “pointer to `T1`” to the type “pointer
 to `T2`” casts away constness.
+[*Note 3*: Some conversions which involve only changes in
+cv-qualification cannot be done using `const_cast.` For instance,
+conversions between pointers to functions are not covered because such
+conversions lead to values whose use causes undefined behavior. For the
+same reasons, conversions between pointers to member functions, and in
+particular, the conversion from a pointer to a const member function to
+a pointer to a non-const member function, are not
+covered. — *end note*]

Diff to HTML by rtfpessoa