Const_cast è sicuro?

Non riesco a trovare molte informazioni su const_cast. Le uniche informazioni che sono riuscito a trovare (su Stack Overflow) sono:

La const_cast<>()è usato per aggiungere / rimuovere const (Ness) (o volatili-Ness) di una variabile.

Questo mi rende nervoso. L'utilizzo di un const_castcomportamento imprevisto potrebbe causare? E allora?

In alternativa, quando è possibile utilizzarlo const_cast?

const_castè sicuro solo se stai eseguendo il casting di una variabile che originariamente non era const. Ad esempio, se si dispone di una funzione che accetta un parametro di a const char *e si passa a un modificabile char *, è sicuro const_castriportare quel parametro a a char *e modificarlo. Tuttavia, se la variabile originale era in effetti const, l'utilizzo const_castrisulterà in un comportamento indefinito.

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 pensare a due situazioni in cui const_cast è sicuro e utile (potrebbero esserci altri casi validi).

Uno è quando si dispone di un'istanza, di un riferimento o di un puntatore const e si desidera passare un puntatore o un riferimento a un'API che non è corretto per const, ma che si è CERTI di non modificare l'oggetto. Puoi const_cast il puntatore e passarlo all'API, confidando che non cambierà davvero nulla. Per esempio:

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

L'altro è se stai usando un vecchio compilatore che non implementa 'mutable' e vuoi creare una classe che sia logicamente const ma non bit per bit. Puoi const_cast 'this' all'interno di un metodo const e modificare i membri della tua 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];
    }
};

Trovo difficile credere che questa sia l' unica informazione che puoi trovare su const_cast. Citando dal secondo successo di Google :

Se si elimina la costanza di un oggetto che è stato esplicitamente dichiarato come const e si tenta di modificarlo, i risultati non sono definiti.

Tuttavia, se si elimina la costanza di un oggetto che non è stato esplicitamente dichiarato come const, è possibile modificarlo in modo sicuro.

Quello che dice Adam. Un altro esempio in cui const_cast può essere utile:

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

Per prima cosa aggiungiamo const al tipo a cui thispunta, quindi chiamiamo la versione const di getTe quindi rimuoviamo const dal tipo restituito, che è valido poiché tdeve essere non const (altrimenti, la versione non const di getTnon potrebbe avere stato chiamato). Questo può essere molto utile se hai un corpo di funzione di grandi dimensioni e vuoi evitare il codice ridondante.

La risposta breve è no, non è sicuro.

La risposta lunga è che se ne sai abbastanza per usarlo, allora dovrebbe essere sicuro.

Quando effettui il casting, quello che stai dicendo essenzialmente è: "So qualcosa che il compilatore non sa". Nel caso di const_cast, quello che stai dicendo è: "Anche se questo metodo accetta un riferimento o un puntatore non const, so che non cambierà il parametro, lo passo".

Quindi, se sai effettivamente cosa pretendi di sapere usando il cast, allora va bene usarlo.

Stai distruggendo ogni possibilità di thread-safety, se inizi a modificare cose che il compilatore pensava fossero const.

#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