O const_cast é seguro?

Não consigo encontrar muitas informações sobre const_cast. A única informação que consegui encontrar (no Stack Overflow) é:

O const_cast<>()é usado para adicionar / remover const (ness) (ou volatile-ness) de uma variável.

Isso me deixa nervoso. Poderia usar um const_castcomportamento inesperado de causa? Se sim, o quê?

Como alternativa, quando posso usar const_cast?

const_casté seguro apenas se você estiver lançando uma variável que originalmente não era const. Por exemplo, se você tem uma função que recebe um parâmetro de a const char *e passa um modificável char *, é seguro const_castvoltar a esse parâmetro para a char *e modificá-lo. No entanto, se a variável original era de fato const, o uso const_castresultará em um comportamento 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

Posso pensar em duas situações em que const_cast é seguro e útil (pode haver outros casos válidos).

Uma é quando você tem uma instância const, referência ou ponteiro e deseja passar um ponteiro ou referência a uma API que não é const-correta, mas que você CERTAIN não modificará o objeto. Você pode const_cast o ponteiro e passá-lo para a API, confiando que isso não mudará nada. Por exemplo:

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()));
}

A outra é se você estiver usando um compilador mais antigo que não implementa 'mutável' e quiser criar uma classe que seja logicamente const, mas não bit a bit const. Você pode const_cast 'this' dentro de um método const e modificar membros de sua classe.

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];
    }
};

Acho difícil acreditar que essa é a única informação que você pode encontrar sobre const_cast. Citando o segundo hit do Google :

Se você descartar a constância de um objeto que foi explicitamente declarado como const e tentar modificá-lo, os resultados serão indefinidos.

No entanto, se você descartar a constância de um objeto que não foi declarado explicitamente como const, poderá modificá-lo com segurança.

O que Adam diz. Outro exemplo onde const_cast pode 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;
};

Primeiro adicionamos const aos thispontos de tipo , então chamamos a versão const de getT, e então removemos const do tipo de retorno, que é válido, pois tdeve ser não-const (caso contrário, a versão não-const de getTnão poderia ter foi chamado). Isso pode ser muito útil se você tiver um corpo de função grande e quiser evitar código redundante.

A resposta curta é não, não é seguro.

A resposta longa é que, se você souber o suficiente para usá-lo, ele deve ser seguro.

Quando você está lançando, o que essencialmente está dizendo é: "Eu sei algo que o compilador não sabe." No caso de const_cast, o que você está dizendo é: "Mesmo que este método aceite uma referência ou ponteiro não const, eu sei que ele não mudará o parâmetro que eu passar."

Portanto, se você realmente sabe o que afirma saber ao usar o gesso, não há problema em usá-lo.

Você está destruindo qualquer chance de thread-safety, se começar a modificar coisas que o compilador pensava que eram 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;
}

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