const_cast conversion

Convierte entre tipos con diferente calificación cv.

Sintaxis

Devuelve un valor de tipo target-type .

Explicación

Solo las siguientes conversiones se pueden realizar con const_cast :

Como con todas las expresiones de conversión, el resultado es:

• un lvalue si target-type es un tipo de referencia lvalue o una referencia rvalue a tipo función (desde C++11) ;

• un prvalue en caso contrario.

Eliminación de constancia

Para dos tipos diferentes T1 y T2 , una conversión de T1 a T2 elimina constancia si existe una descomposición de calificación de T2 de la forma “cv2_0 P2_0 cv2_1 P2_1 ... cv2_n−1 P2_n−1 cv2_n U2”, y no hay conversiones de calificación que conviertan T1 a “cv2_0 P1_0 cv2_1 P1_1 ... cv2_n−1 P1_n−1 cv2_n U1” (mismos componentes cv, diferentes componentes P y componentes U).

Si una conversión de un prvalue de tipo T1* al tipo T2* elimina constness, convertir de una expresión de tipo T1 a una referencia a T2 también eliminará constness.

Solo const_cast puede utilizarse para eliminar la constancia.

"Descartar la constancia" implica "descartar la volatilidad", ya que las conversiones de calificación tampoco pueden descartar la volatilidad.

Notas

Los punteros a funciones y los punteros a funciones miembro no están sujetos a const_cast .

const_cast permite formar una referencia o puntero a un tipo no constante que en realidad se refiere a un objeto constante o una referencia o puntero a un tipo no volátil que en realidad se refiere a un objeto volátil . Modificar un objeto constante a través de una ruta de acceso no constante y referirse a un objeto volátil a través de un glvalue no volátil resulta en comportamiento indefinido.

Palabras clave

const_cast

Ejemplo

#include <iostream>
struct type
{
    int i;
    type(): i(3) {}
    void f(int v) const
    {
        // this->i = v;                 // error de compilación: this es un puntero a const
        const_cast<type*>(this)->i = v; // OK mientras el objeto type no sea const
    }
};
int main()
{
    int i = 3;                 // i no está declarado como const
    const int& rci = i;
    const_cast<int&>(rci) = 4; // OK: modifica i
    std::cout << "i = " << i << '\n';
    type t; // si esto fuera const type t, entonces t.f(4) sería comportamiento indefinido
    t.f(4);
    std::cout << "type::i = " << t.i << '\n';
    const int j = 3; // j está declarado como const
    [[maybe_unused]]
    int* pj = const_cast<int*>(&j);
    // *pj = 4;      // comportamiento indefinido
    [[maybe_unused]]
    void (type::* pmf)(int) const = &type::f; // puntero a función miembro
    // const_cast<void(type::*)(int)>(pmf);   // error de compilación: const_cast no
                                              // funciona con punteros a función
}

i = 4
type::i = 4

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares publicados anteriormente de C++.

Referencias

Véase también

• static_cast
• dynamic_cast
• reinterpret_cast
• conversión explícita
• conversiones implícitas