Ist const_cast sicher?

Ich kann nicht viele Informationen finden const_cast. Die einzige Information, die ich finden konnte (über Stapelüberlauf), ist:

Das const_cast<>()wird verwendet, um Konstante (oder Flüchtigkeit) einer Variablen hinzuzufügen / zu entfernen.

Das macht mich nervös. Könnte ein const_castunerwartetes Verhalten auftreten? Wenn ja, was?

Alternativ, wann ist es in Ordnung zu verwenden const_cast?

const_castist nur dann sicher, wenn Sie eine Variable umwandeln, die ursprünglich nicht war const. Wenn Sie beispielsweise eine Funktion haben, die einen Parameter von a übernimmt const char *, und eine veränderbare Funktion übergeben char *, ist es sicher, const_castdass dieser Parameter an a zurückgegeben char *und geändert wird. Wenn jedoch die ursprüngliche Variable tatsächlich war const, führt die Verwendung const_castzu undefiniertem Verhalten.

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

Ich kann mir zwei Situationen vorstellen, in denen const_cast sicher und nützlich ist (es kann andere gültige Fälle geben).

Eine ist, wenn Sie eine const-Instanz, eine Referenz oder einen Zeiger haben und einen Zeiger oder eine Referenz an eine API übergeben möchten, die nicht const-korrekt ist, aber Sie BESTIMMT sind, ändert das Objekt nicht. Sie können den Zeiger const_cast und an die API übergeben, wobei Sie darauf vertrauen, dass er nichts wirklich ändert. Beispielsweise:

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

Die andere Möglichkeit besteht darin, einen älteren Compiler zu verwenden, der 'mutable' nicht implementiert, und eine Klasse erstellen möchten, die logisch const, aber nicht bitweise const ist. Sie können const_cast 'this' innerhalb einer const-Methode und Mitglieder Ihrer Klasse ändern.

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

Es fällt mir schwer zu glauben, dass dies die einzigen Informationen sind, die Sie über const_cast finden können. Zitat aus dem zweiten Google-Hit :

Wenn Sie die Konstanz eines Objekts, das explizit als const deklariert wurde, wegwerfen und versuchen, es zu ändern, sind die Ergebnisse undefiniert.

Wenn Sie jedoch die Konstanz eines Objekts, das nicht explizit als const deklariert wurde, wegwerfen, können Sie es sicher ändern.

Was Adam sagt. Ein weiteres Beispiel, bei dem const_cast hilfreich sein kann:

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

Wir fügen zuerst const zu den Typpunkten hinzu, thisrufen dann die const-Version von auf getTund entfernen dann const aus dem Rückgabetyp, der gültig ist, da ter nicht const sein muss (andernfalls könnte die nicht-const-Version von getTnicht haben wurde genannt). Dies kann sehr nützlich sein, wenn Sie einen großen Funktionskörper haben und redundanten Code vermeiden möchten.

Die kurze Antwort lautet nein, es ist nicht sicher.

Die lange Antwort lautet: Wenn Sie genug wissen, um es zu verwenden, sollte es sicher sein.

Beim Casting sagen Sie im Wesentlichen: "Ich weiß etwas, das der Compiler nicht weiß." Im Fall von const_cast sagen Sie: "Obwohl diese Methode eine nicht konstante Referenz oder einen Zeiger verwendet, weiß ich, dass sie den Parameter, den ich übergebe, nicht ändert."

Wenn Sie also tatsächlich wissen, was Sie bei der Verwendung der Besetzung zu wissen behaupten, ist es in Ordnung, sie zu verwenden.

Sie zerstören jede Chance auf Thread-Sicherheit, wenn Sie anfangen, Dinge zu ändern, die der Compiler für konstant hielt.

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

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