¿Es const_cast seguro?

No puedo encontrar mucha información sobre const_cast. La única información que pude encontrar (en Stack Overflow) es:

Se const_cast<>()utiliza para agregar / eliminar la const (ness) (o volatile-ness) de una variable.

Esto me pone nervioso. ¿El uso de un const_castcomportamiento podría causar un comportamiento inesperado? ¿Entonces qué?

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

const_castes seguro solo si está lanzando una variable que originalmente no era const. Por ejemplo, si tiene una función que toma un parámetro de a const char *, y pasa un modificable char *, es seguro que const_castese parámetro vuelva a a char *y lo modifique. Sin embargo, si la variable original era de hecho const, el uso const_castresultará en 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

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

Una es cuando tiene una instancia, referencia o puntero constante, y desea pasar un puntero o referencia a una API que no es correcta const, pero está SEGURO de 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 si está utilizando un compilador más antiguo que no implementa 'mutable', y desea crear una clase que sea lógicamente constante pero no 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];
    }
};

Me cuesta creer que esa sea la única información que pueda encontrar sobre const_cast. Citando del segundo éxito de Google :

Si descarta la constness de un objeto que se ha declarado explícitamente como const e intenta modificarlo, los resultados no están definidos.

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

Lo que dice Adam. 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;
};

Primero agregamos const al tipo thisapunta a, luego llamamos a la versión const de getT, y luego eliminamos const del tipo de retorno, que es válido ya que tdebe ser no constante (de lo contrario, la versión no constante de getTno podría tener ha sido llamado). Esto puede resultar muy útil si tiene un cuerpo de función grande y desea evitar el código redundante.

La respuesta corta es no, no es seguro.

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

Cuando estás transmitiendo, lo que esencialmente estás diciendo es: "Sé algo que el compilador no sabe". En el caso de const_cast, lo que está diciendo es: "Aunque este método toma una referencia o un puntero no constante, sé que no cambiará el parámetro que le paso".

Entonces, si realmente sabe lo que dice saber al usar el yeso, entonces está bien usarlo.

Está destruyendo cualquier posibilidad de seguridad de subprocesos, si comienza a modificar cosas que el compilador pensaba que eran constantes.

#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