const_cast conversion

Konvertiert zwischen Typen mit unterschiedlicher CV-Qualifikation.

Syntax

Gibt einen Wert vom Typ target-type zurück.

Erklärung

Nur die folgenden Konvertierungen können mit const_cast durchgeführt werden:

Wie bei allen Cast-Ausdrücken ist das Ergebnis:

• ein lvalue, wenn target-type ein lvalue reference type ist oder ein rvalue reference to function type (seit C++11) ;

• ein prvalue andernfalls.

Entfernen der Konstanz

Für zwei verschiedene Typen T1 und T2 entfernt eine Konvertierung von T1 zu T2 Constness , wenn es eine Qualifikationszerlegung von T2 der Form „cv2_0 P2_0 cv2_1 P2_1 ... cv2_n−1 P2_n−1 cv2_n U2“ gibt und keine Qualifikationskonvertierung existiert, die T1 zu „cv2_0 P1_0 cv2_1 P1_1 ... cv2_n−1 P1_n−1 cv2_n U1“ konvertiert (gleiche cv-Komponenten, verschiedene P- und U-Komponenten).

Wenn eine Konvertierung von einem Prvalue des Typs T1* zum Typ T2* die Constness entfernt, dann entfernt auch die Konvertierung eines Ausdrucks des Typs T1 zu einer Referenz auf T2 die Constness.

Nur const_cast kann verwendet werden, um Constness wegzucasten.

"Casting away constness" impliziert "casting away volatility", da Qualifikationskonvertierungen ebenfalls Volatilität nicht entfernen können.

Hinweise

Zeiger auf Funktionen und Zeiger auf Elementfunktionen unterliegen nicht const_cast .

const_cast ermöglicht es, eine Referenz oder einen Zeiger auf einen nicht-konstanten Typ zu bilden, der tatsächlich auf ein const-Objekt verweist, oder eine Referenz oder einen Zeiger auf einen nicht-flüchtigen Typ, der tatsächlich auf ein volatile-Objekt verweist. Das Modifizieren eines const-Objekts über einen nicht-konstanten Zugriffspfad und das Referenzieren eines volatile-Objekts über einen nicht-flüchtigen glvalue führt zu undefiniertem Verhalten.

Schlüsselwörter

const_cast

Beispiel

#include <iostream>
struct type
{
    int i;
    type(): i(3) {}
    void f(int v) const
    {
        // this->i = v;                 // Kompilierfehler: this ist ein Zeiger auf const
        const_cast<type*>(this)->i = v; // OK solange das type-Objekt nicht const ist
    }
};
int main()
{
    int i = 3;                 // i ist nicht als const deklariert
    const int& rci = i;
    const_cast<int&>(rci) = 4; // OK: modifiziert i
    std::cout << "i = " << i << '\n';
    type t; // wenn dies const type t wäre, dann wäre t.f(4) undefiniertes Verhalten
    t.f(4);
    std::cout << "type::i = " << t.i << '\n';
    const int j = 3; // j ist als const deklariert
    [[maybe_unused]]
    int* pj = const_cast<int*>(&j);
    // *pj = 4;      // undefiniertes Verhalten
    [[maybe_unused]]
    void (type::* pmf)(int) const = &type::f; // Zeiger auf Member-Funktion
    // const_cast<void(type::*)(int)>(pmf);   // Kompilierfehler: const_cast funktioniert
                                              // nicht bei Funktionszeigern
}

i = 4
type::i = 4

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

Referenzen

Siehe auch

• static_cast
• dynamic_cast
• reinterpret_cast
• Explizite Konvertierung
• Implizite Konvertierungen