7 Expressions [expr]

7.6 Compound expressions [expr.compound]

7.6.1 Postfix expressions [expr.post]

7.6.1.11 Const cast [expr.const.cast]

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, array-to-pointer, and function-to-pointer 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 subclause, an expression can be cast to its own type using a const_cast operator.

— end note]

For two similar types T1 and T2, a prvalue of type T1 may be explicitly converted to the type T2 using a const_cast if, considering the cv-decompositions of both types, each

P_{i}^{1}

is the same as

P_{i}^{2}

for all i.

The result of a const_cast refers to the original entity.

[Example 1: 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:

(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 otherwise.

A null pointer value ([basic.compound]) 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-qualifier71 might 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 of T1 yielding n such that T2 has a cv-decomposition of the form

c v_{0}^{2}

P_{0}^{2}

c v_{1}^{2}

P_{1}^{2}

⋯

c v_{n - 1}^{2}

P_{n - 1}^{2}

c v_{n}^{2}

U_{2}

, and there is no qualification conversion that converts T1 to

c v_{0}^{2}

P_{0}^{1}

c v_{1}^{2}

P_{1}^{1}

⋯

c v_{n - 1}^{2}

P_{n - 1}^{1}

c v_{n}^{2}

U_{1}

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]

71)

const_cast is not limited to conversions that cast away a const-qualifier.

⮥