Casting-Operatoren werden für die Typumwandlung in C++ verwendet. Sie werden verwendet, um einen Datentyp in einen anderen zu konvertieren. C++ unterstützt vier Arten von Umwandlungen:
- static_cast
- dynamischer_cast
- const_cast
- reinterpret_cast
1. static_cast
Der static_cast Der Operator ist der am häufigsten verwendete Casting-Operator in C++. Es führt eine Typkonvertierung zur Kompilierungszeit durch und wird hauptsächlich für explizite Konvertierungen verwendet, die vom Compiler als sicher angesehen werden.
Syntax von static_cast
static_cast < new_type>(Ausdruck);>
Wo,
- Ausdruck: Zu konvertierende Daten.
- neuer Typ: Gewünschte Ausdrucksart
Der static_cast kann zum Konvertieren zwischen verwandten Typen verwendet werden, z. B. numerischen Typen oder Zeigern in derselben Vererbungshierarchie.
Beispiel für static_cast
C++ // C++ program to illustrate the static_cast #include #include using namespace std; int main() { int num = 10; // converting int to double double numDouble = static_cast(Anzahl); // Druckdatentyp cout<< typeid(num).name() << endl; // typecasting cout << typeid(static_cast(num)).name()<< endl; // printing double type t cout << typeid(numDouble).name() << endl; return 0; }> Ausgabe
i d d>
In diesem Beispiel haben wir Folgendes eingefügt Typinfo Bibliothek, damit wir sie nutzen können Typ-ID() Funktion zur Überprüfung des Datentyps. Wir haben eine ganzzahlige Variable „num“ definiert und sie mithilfe von static_cast in ein Double umgewandelt. Danach drucken wir die Datentypen der Variablen aus und übergeben sie static_cast(num) In typeid() Funktion zur Überprüfung des Datentyps. Wir können sehen, dass die Ausgabe i, d, d dort gedruckt wird 'ich' bezeichnet ganze Zahl Und 'D' bezeichnet doppelt .
2. dynamischer_cast
Der dynamischer_cast Der Operator wird hauptsächlich zum Downcasting (Konvertieren eines Zeigers/einer Referenz einer Basisklasse in eine abgeleitete Klasse) verwendet. Es stellt die Typsicherheit sicher, indem es eine Laufzeitprüfung durchführt, um die Gültigkeit der Konvertierung zu überprüfen.
Syntax von Dynamic_cast
dynamic_cast < new_type>(Ausdruck);>
Sollte die Konvertierung nicht möglich sein, dynamischer_cast gibt a zurück Null Zeiger (für Zeigerkonvertierungen) oder wirft a bad_cast-Ausnahme (für Referenzumrechnungen).
Beispiel für Dynamic_cast
C++ // C++ program to illustrate the dynamic_cast #include using namespace std; // Base Class class Animal { public: virtual void speak() const { cout << 'Animal speaks.' << endl; } }; // Derived Class class Dog : public Animal { public: void speak() const override { cout << 'Dog barks.' << endl; } }; // Derived Class class Cat : public Animal { public: void speak() const override { cout << 'Cat meows.' << endl; } }; int main() { // base class pointer to derived class object Animal* animalPtr = new Dog(); // downcasting Dog* dogPtr = dynamic_cast(TierPtr); // Prüfung, ob die Typumwandlung erfolgreich ist if (dogPtr) { dogPtr->speak(); } else { cout<< 'Failed to cast to Dog.' << endl; } // typecasting to other dervied class Cat* catPtr = dynamic_cast(TierPtr); if (catPtr) { catPtr->speak(); } else { cout<< 'Failed to cast to Cat.' << endl; } delete animalPtr; return 0; }> Ausgabe
Dog barks. Failed to cast to Cat.>
Erläuterung: Die erste Ausgabezeile wird gedruckt, weil die „animalPtr“ des 'Tier' Typ wurde erfolgreich in umgewandelt 'Hund' Typ und sprechen() Die Funktion der Dog-Klasse wird aufgerufen, aber die Umwandlung der 'Tier' Geben Sie ein 'Katze' Typ ist fehlgeschlagen, weil „animalPtr“ deutet auf a 'Hund' Daher schlägt die dynamische Umwandlung fehl, da die Typumwandlung nicht sicher ist.
3. const_cast
Der const_cast Der Operator wird verwendet, um das const- oder volatile-Qualifikationsmerkmal einer Variablen zu ändern. Es ermöglicht Programmierern, die Konstanz eines Objekts vorübergehend aufzuheben und Änderungen vorzunehmen. Bei der Verwendung von const_cast ist Vorsicht geboten, da das Ändern eines const-Objekts zu undefiniertem Verhalten führen kann.
Syntax für const_cast
const_cast < new_type>(Ausdruck);>
Beispiel für const_cast
C++ // C++ program to illustrate the const_cast #include using namespace std; int main() { const int number = 5; // Pointer to a const int const int* ptr = &number; // int* nonConstPtr = ptr; if we use this // instead of without using const_cast // we will get error of invalid conversion int* nonConstPtr = const_cast (ptr); *nonConstPtr = 10; cout<< 'Modified number: ' << *nonConstPtr; return 0; }> Ausgabe
Modified number: 10>
Im obigen Beispiel haben wir den Wert von geändert const-Typ Zeiger durch Ändern seines Qualifikationsmerkmals von const Zu nicht-konst und dann den geänderten Wert drucken.
4. reinterpret_cast
Der reinterpret_cast-Operator wird verwendet, um den Zeiger in einen beliebigen anderen Zeigertyp umzuwandeln. Es wird keine Prüfung durchgeführt, ob der konvertierte Zeiger vom gleichen Typ ist oder nicht.
Syntax von reinterpret_cast
reinterpret_cast < new_type>(Ausdruck);>
Beispiel
C++ // C++ program to illustrate the reinterpret_cast #include using namespace std; int main() { int number = 10; // Store the address of number in numberPointer int* numberPointer = &number; // Reinterpreting the pointer as a char pointer char* charPointer = reinterpret_cast(Zahlenzeiger); // Drucken der Speicheradressen und -werte cout<< 'Integer Address: ' << numberPointer << endl; cout << 'Char Address: ' << reinterpret_cast(charPointer)<< endl; return 0; }> Ausgabe
Integer Address: 0x7fff64789f1c Char Address: 0x7fff64789f1c>
Im obigen Beispiel haben wir eine int-Variable definiert 'Nummer' und speichern Sie dann die Adresse von „Nummer“ in „numberPointer“ vom Typ int, nachdem wir die konvertiert haben „numberPointer“ vom Typ int in den char-Zeiger und speichern Sie ihn dann darin „charPointer“ Variable. Um zu überprüfen, ob wir die Adresse von numberPointer und charPointer gedruckt haben. Um die in „charPointer“ gespeicherte Adresse auszudrucken reinterpret_cast wird verwendet, um den Typprüfungsmechanismus von C++ zu umgehen und die Ausgabe des Zeigers als generische Speicheradresse ohne typspezifische Interpretation zu ermöglichen.
Notiz: const_cast und reinterpret_cast werden im Allgemeinen nicht empfohlen, da sie anfällig für verschiedene Arten von Fehlern sind.