8 Expressions [expr]

8.2 Postfix expressions [expr.post]

8.2.11 Const cast [expr.const.cast]

1
#
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 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 const_­cast are listed below.
No other conversion shall be performed explicitly using const_­cast.
2
#
[ Note
:
Subject to the restrictions in this section, an expression may be cast to its own type using a const_­cast operator.
— end note
 ]
3
#
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
: 
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
 ]
4
#
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:
  • (4.1)
    an lvalue of type T1 can be explicitly converted to an lvalue of type T2 using the cast const_­cast<T2&>;
  • (4.2)
    a glvalue of type T1 can be explicitly converted to an xvalue of type T2 using the cast const_­cast<T2&&>; and
  • (4.3)
    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.
5
#
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.
6
#
[ Note
:
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-qualifier76 may produce undefined behavior ([dcl.type.cv]).
— end note
 ]
7
#
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
⋯ .
8
#
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.
9
#
[ Note
:
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
 ]
76)
const_­cast is not limited to conversions that cast away a const-qualifier.