Usos correctos de const_cast <>

Question

Como regla general, a menudo se considera una mala práctica usar const_cast<>() en código C++ ya que revela (la mayoría de las veces) un defecto en el diseño.

Si bien estoy totalmente de acuerdo con esto, sin embargo pregunto cuáles son los casos estaban usando const_cast<>() es bien y la única solución .

Podrían ustedes por favor, dame algunos ejemplos que conoce/encontrado?

Muchas gracias.

Answer 1

const_cast también se utiliza para eliminar volatile modificadores, como poner en práctica en este() artículo controversed:

http://www.drdobbs.com/184403766

Answer 2

Es más o menos diseñado para ser utilizado con las API de legado que no están const correcta es decir, con una función que no puede cambiar eso tiene interfaz no const pero en realidad no mutan nada en la interfaz

Answer 3

Sí por supuesto, cuando su código de llamada no puede modificarse y no es const correcto. ¡Debe tenerse en cuenta que solo debe usarlo con llamadas a funciones que, con certeza, no modificarán sus datos!

Answer 4

Estoy de acuerdo con su declaración de que su uso normal es porque es necesario para ocultar un 'defecto de diseño'.

IME uno de los escenarios de uso típico es cuando intenta interactuar C++ para el código C existente. Una gran cantidad de código C existente lleva cadenas de C como char * incluso cuando la cadena no se modifica mientras que por lo general están representados como algo que se convierte en un const char * en C++. Esa es una discrepancia de impedancia entre los dos lenguajes que normalmente resolverías usando un const_cast. Por supuesto, es mejor que ser muy asegurarse de que el código que está interconexión con no recibe ninguna idea lindo acerca de cómo modificar los datos que se pasa en.

yo diría que se trata de un código de olores en recién escrito código, pero para interactuar con el código anterior de C y C++, es un mal necesario. Dicho esto, sería extremadamente cuidadoso de código que requiere const_cast por cualquier objeto no-POD ya que es normalmente un problema que debe ser resuelto a nivel de diseño y no el nivel de código.

Answer 5

Un uso muy legítima de esto es cuando se tiene tanto una constante y API no const (por const y no objetos, respectivamente const) como en

class Bar { 
    const SomeType& foo() const; 
    SomeType& foo(); 
} 

Entonces ya no queremos duplicar el código en ambas funciones a menudo utilizamos

class Bar { 
    SomeType& foo() { 
     //Actual implementation 
    } 
    const SomeType& foo() const { 
     return const_cast<Bar*>(this)->foo(); 
    } 
}; 

Esto es, por supuesto, asumiendo que foo no hace algo que viola la semántica const.

Answer 6

Como otros han dicho, su propósito principal es eliminar const de los objetos para pasar a las funciones no conformes que usted sabe que no modificarán el argumento.

Hay un truco (por Meyers?) Para evitar la duplicación de código, y se va así:

struct foo 
{ 
    const return_type& get(void) const 
    { 
     // fancy pants code that you definitely 
     // don't want to repeat 

     return theValue; // and got it 
    } 

    return_type& get(void) 
    { 
     // well-defined: Add const to *this, 
     // call the const version, then 
     // const-cast to remove const (because 
     // *this is non-const, this is ok) 
     return const_cast<return_type&>(static_cast<const foo&>(*this).get()); 
    } 
}; 

Answer 7

Una legítimo uso (en mi opinión) es con iteradores std::set. Siempre son const, para evitar el cambio de la clave utilizada en el conjunto. Cambiar la clave rompería la estructura interna del conjunto y provocaría un comportamiento indefinido.

Sin embargo, mientras la clave no cambie, es seguro cambiar otros datos en el objeto.

Digamos que usted tiene una std::set así:

std::set<MyObject> some_set; 

Y una clase como esta:

class MyObject { 
    public: 
     MyObject(const std::string &key) 
      : key_(key) {} 

     bool operator<(const MyObject &other) const { 
      return key_ < other.key_; 
     } 

    private: 
     // ... 
     // <some other data> 
     // ... 

     const std::string key_; 
}; 

En el ejemplo anterior, la tecla ya está const, por lo que incluso si modificar el objeto, no se puede romper la estructura interna del conjunto.

Normalmente sólo se puede obtener una referencia const de un iterador de conjunto:

const MyObject &object = *some_set_iterator; 

Pero ya que la clave es const, que es seguro const_cast el iterador sin referencia:

MyObject &object = const_cast<MyObject &>(*some_set_iterator);