Korrekte Verwendung (en) von const_cast <>

Question

Als eine allgemeine Regel wird es sehr häufig als eine schlechte Praxis betrachtet, const_cast<>() in C++ - Code zu verwenden, da es (meistens) einen Fehler im Design offenbart.

Während ich völlig damit einverstanden, ich aber frage mich, was sind die Fälle const_cast<>() wurden verwendet, ist ok und die einzige Lösung.

Könntest du mir bitte ein paar Beispiele nennen, die du kennst?

Vielen Dank.

Answer 1

const_cast auch volatile Modifikatoren, zu entfernen, wie in diesem (controversed) Artikel in die Praxis umgesetzt:

http://www.drdobbs.com/184403766

Answer 2

es ziemlich viel ist ausschließlich mit Legacy-APIs verwendet werden, die nicht korrekt, dh mit einer Funktion const sind Sie nicht, dass hat nicht const Schnittstelle tatsächlich ändert, aber nichts an der Schnittstelle

Answer 3

mutieren Ja natürlich, wenn dein calling code das du nicht ändern kannst und nicht const korrekt ist. Es sollte beachtet werden, dass Sie es nur bei Aufrufen von Funktionen verwenden sollten, von denen Sie sicher wissen, dass sie Ihre Daten nicht verändern werden!

Answer 4

Ich stimme Ihrer Aussage zu, dass sie normalerweise verwendet wird, weil Sie einen "Designfehler" verbergen müssen.

IME eines der typischen Anwendungsszenarien ist, wenn Sie versuchen, C++ mit vorhandenem C-Code zu verbinden. Viele vorhandene C-Code nimmt C-Zeichenfolgen als char *, auch wenn die Zeichenfolge nicht geändert wird, während sie in der Regel als etwas dargestellt werden, das in C++ zu einem const char * konvertiert. Das ist eine Impedanzabweichung zwischen den beiden Sprachen, die Sie normalerweise mit einem const_cast lösen würden. Natürlich sollten Sie besser sein sehr sicher, dass der Code, den Sie mit Schnittstellen sind keine süßen Ideen über die Änderung der Daten, die gerade übergeben wird.

Ich würde sagen, dass es ein Code riecht in neu geschrieben Code, aber für die Schnittstelle mit älteren C-und C++ - Code ist es ein notwendiges Übel. Nichtsdestoweniger würde ich sehr vorsichtig sein von Code, der const_cast für alle Nicht-POD-Objekte erfordert, da dies normalerweise ein Problem ist, das auf der Design-Ebene und nicht auf der Code-Ebene gelöst werden sollte.

Answer 5

Eine sehr berechtigte Verwendung dafür ist, wenn Sie sowohl eine const und nicht const api (für const und nicht const-Objekte bezeichnet), wie in

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

Dann, da wir nicht wollen, um den Code duplizieren in beiden Funktionen oft wir

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

verwenden Dies ist natürlich, dass foo unter der Annahme, etwas nicht tun, die die const Semantik verletzt.

Answer 6

Wie andere gesagt haben, ist sein Hauptzweck, const von Objekten zu entfernen, um nicht-const korrekte Funktionen zu übergeben, die Sie wissen, wird das Argument nicht ändern.

Es gibt einen Trick (von Meyers?) Code Doppelarbeit zu vermeiden, und es geht so:

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

Ein legitimes Verwenden Sie (meiner Meinung nach) mit std::set Iteratoren. Sie sind immer const, um das Ändern des im Satz verwendeten Schlüssels zu verhindern. Das Ändern des Schlüssels würde die interne Struktur des Satzes zerstören und zu undefiniertem Verhalten führen.

Solange jedoch der Schlüssel nicht geändert wird, ist es sicher, andere Daten im Objekt zu ändern.

Angenommen, Sie haben einen std::set wie dieses:

std::set<MyObject> some_set; 

Und eine Klasse wie folgt aus:

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

In dem obigen Beispiel der Schlüssel ist bereits const, also auch wenn Sie Ändern Sie das Objekt, Sie können die interne Struktur des Satzes nicht brechen.

Normalerweise kann man nur erhalten eine const Referenz aus einem Satz Iterator:

const MyObject &object = *some_set_iterator; 

Aber da der Schlüssel const ist, dann ist es sicher const_cast die dereferenzierte Iterator:

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