¿Es const_cast seguro?

Question

No encuentro mucha información en const_cast. La única información que pude encontrar (desbordamiento de pila) es:

la const_cast<>() se utiliza para añadir/quitar const (Ness) (o-dad volátil) de una variable.

Esto me pone nervioso. ¿Podría el uso de un const_cast causar un comportamiento inesperado? ¿Entonces qué?

Alternativamente, ¿cuándo está bien usar const_cast?

Answer 1

const_cast es seguro solo si está emitiendo una variable que originalmente no era const. Por ejemplo, si tiene una función que toma un parámetro de const char *, y pasa un char * modificable, es seguro const_cast ese parámetro volver a un char * y modificarlo. Sin embargo, si la variable original era de hecho const, entonces usar const_cast dará como resultado un comportamiento indefinido.

void func(const char *param, size_t sz, bool modify) 
{ 
    if(modify) 
     strncpy(const_cast<char *>(param), sz, "new string"); 
    printf("param: %s\n", param); 
} 

... 

char buffer[16]; 
const char *unmodifiable = "string constant"; 
func(buffer, sizeof(buffer), true); // OK 
func(unmodifiable, strlen(unmodifiable), false); // OK 
func(unmodifiable, strlen(unmodifiable), true); // UNDEFINED BEHAVIOR 

Answer 2

Me resulta difícil creer que esa es la única información se podía encontrar sobre const_cast. Citando el second Google hit:

Si desecharon la constness de un objeto que ha sido explícitamente declarada como const, y tratar de modificarlo, los resultados son indefinidos.

Sin embargo, si se desecharon la constness de un objeto que no ha sido declarado explícitamente como const, que puede modificar de forma segura.

Answer 3

Estás destruyendo cualquier posibilidad de seguridad en el hilo, si comienzas a modificar las cosas que el compilador creía que eran const.

Answer 4

Lo que Adam dice. Otro ejemplo en el que const_cast puede ser útil:

struct sample { 
    T& getT() { 
     return const_cast<T&>(static_cast<const sample*>(this)->getT()); 
    } 

    const T& getT() const { 
     /* possibly much code here */ 
     return t; 
    } 

    T t; 
}; 

En primer lugar, añadir const al tipo this puntos a, entonces llamamos a la versión const de getT, y luego quitar const del tipo de retorno, lo cual es válido, ya que t debe ser no const (de lo contrario, no se podría haber llamado a la versión no const de getT). Esto puede ser muy útil si tiene un cuerpo de función grande y desea evitar el código redundante.

Answer 5

Puedo pensar en dos situaciones donde const_cast es seguro y útil (puede haber otros casos válidos).

Una es cuando tiene una instancia, referencia o puntero const, y desea pasar un puntero o referencia a una API que no es const-correcto, pero que está CERTE que no modificará el objeto. Puede const_cast el puntero y pasarlo a la API, confiando en que realmente no cambiará nada. Por ejemplo:

void log(char* text); // Won't change text -- just const-incorrect 

void my_func(const std::string& message) 
{ 
    log(const_cast<char*>(&message.c_str())); 
} 

La otra es que si estás usando un compilador de más edad que no implementa 'mutable', y que desea crear una clase que es, lógicamente, pero no const const bit a bit.Puede const_cast 'this' dentro de un método const y modificar miembros de su clase.

class MyClass 
{ 
    char cached_data[10000]; // should be mutable 
    bool cache_dirty;  // should also be mutable 

    public: 

    char getData(int index) const 
    { 
     if (cache_dirty) 
     { 
      MyClass* thisptr = const_cast<MyClass*>(this); 
      update_cache(thisptr->cached_data); 
     } 
     return cached_data[index]; 
    } 
}; 

Answer 6

La respuesta corta es no, no es seguro.

La respuesta larga es que si sabes lo suficiente como para usarlo, entonces debería ser seguro.

Cuando estás lanzando, lo que básicamente dices es "Sé algo que el compilador no sabe". En el caso de const_cast, lo que está diciendo es: "Aunque este método tiene una referencia o puntero no const, sé que no cambiará el parámetro que lo paso".

Así que si realmente sabes lo que afirmas saber al usar el elenco, está bien usarlo.

Answer 7

#include <iostream> 
using namespace std; 

void f(int* p) { 
    cout << *p << endl; 
} 

int main(void) { 
    const int a = 10; 
    const int* b = &a; 

    // Function f() expects int*, not const int* 
    // f(b); 
    int* c = const_cast<int*>(b); 
    f(c); 

    // Lvalue is const 
    // *b = 20; 

    // Undefined behavior 
    // *c = 30; 

    int a1 = 40; 
    const int* b1 = &a1; 
    int* c1 = const_cast<int*>(b1); 

    // Integer a1, the object referred to by c1, has 
    // not been declared const 
    *c1 = 50; 

    return 0; 
} 

fuente: http://publib.boulder.ibm.com/infocenter/comphelp/v8v101/index.jsp?topic=%2Fcom.ibm.xlcpp8a.doc%2Flanguage%2Fref%2Fkeyword_const_cast.htm