Casting-operatoren worden gebruikt voor het casten van typen in C++. Ze worden gebruikt om het ene gegevenstype naar het andere te converteren. C++ ondersteunt vier soorten casts:
- statische_cast
- dynamische_cast
- const_cast
- herinterpreteer_cast
1. statische_cast
De statische_cast operator is de meest gebruikte castingoperator in C++. Het voert conversies uit tijdens het compileren en wordt voornamelijk gebruikt voor expliciete conversies die door de compiler als veilig worden beschouwd.
Syntaxis van static_cast
static_cast < new_type>(uitdrukking);>
waar,
- uitdrukking: Gegevens die moeten worden geconverteerd.
- nieuw type: Gewenst type expressie
De static_cast kan worden gebruikt om te converteren tussen gerelateerde typen, zoals numerieke typen of pointers in dezelfde overervingshiërarchie.
Voorbeeld van 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(aantal); // afdrukgegevenstype cout<< typeid(num).name() << endl; // typecasting cout << typeid(static_cast(num)).naam()<< endl; // printing double type t cout << typeid(numDouble).name() << endl; return 0; }> Uitvoer
i d d>
In dit voorbeeld hebben we de typeinfo bibliotheek waar we gebruik van kunnen maken typeid() functie om het gegevenstype te controleren. We hebben een integer-variabele ‘num’ gedefinieerd en deze met static_cast in een double omgezet. Daarna drukken we de gegevenstypen van variabelen af en geven we door static_cast(num) in typeid() functie om het gegevenstype te controleren. we kunnen zien dat de uitvoer i, d, d waar wordt afgedrukt 'i' duidt aan geheel getal En 'D' duidt aan dubbele .
2. dynamische_cast
De dynamische_cast operator wordt voornamelijk gebruikt om downcasting uit te voeren (het converteren van een pointer/referentie van een basisklasse naar een afgeleide klasse). Het garandeert typeveiligheid door een runtimecontrole uit te voeren om de geldigheid van de conversie te verifiëren.
Syntaxis van dynamic_cast
dynamic_cast < new_type>(uitdrukking);>
Als de conversie niet mogelijk is, dynamische_cast retourneert een nul punten (voor pointerconversies) of gooit a bad_cast uitzondering (voor referentieconversies).
Voorbeeld van 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(dierPtr); // controleren of de typecasting succesvol is if (dogPtr) { dogPtr->speak(); } anders { cout<< 'Failed to cast to Dog.' << endl; } // typecasting to other dervied class Cat* catPtr = dynamic_cast(dierPtr); if (catPtr) { catPtr->spreek(); } anders { cout<< 'Failed to cast to Cat.' << endl; } delete animalPtr; return 0; }> Uitvoer
Dog barks. Failed to cast to Cat.>
Uitleg: De eerste regel met uitvoer wordt afgedrukt omdat de ‘dierPtr’ van de 'Dier' type is succesvol gecast naar de 'Hond' typ en spreken() functie van de Dog-klasse wordt aangeroepen, maar het casten van de 'Dier' typ naar 'Kat' type is mislukt omdat ‘dierPtr’ wijst naar een 'Hond' object dus mislukt de dynamische cast omdat de typecasting niet veilig is.
3. const_cast
De const_cast operator wordt gebruikt om de const of vluchtige kwalificatie van een variabele te wijzigen. Hiermee kunnen programmeurs tijdelijk de constantheid van een object verwijderen en wijzigingen aanbrengen. Voorzichtigheid is geboden bij het gebruik van const_cast, omdat het wijzigen van een const-object kan leiden tot ongedefinieerd gedrag.
Syntaxis voor const_cast
const_cast < new_type>(uitdrukking);>
Voorbeeld van 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; uit<< 'Modified number: ' << *nonConstPtr; return 0; }> Uitvoer
Modified number: 10>
In het bovenstaande voorbeeld hebben we de waarde van de const-type pointer door de kwalificatie te wijzigen van const naar niet-const en vervolgens de gewijzigde waarde afdrukken.
4. herinterpreteer_cast
De reinterpret_cast-operator wordt gebruikt om de aanwijzer naar een ander type aanwijzer te converteren. Er wordt geen enkele controle uitgevoerd of de geconverteerde aanwijzer van hetzelfde type is of niet.
Syntaxis van reinterpret_cast
reinterpret_cast < new_type>(uitdrukking);>
Voorbeeld
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(nummerwijzer); // Afdrukken van de geheugenadressen en waarden cout<< 'Integer Address: ' << numberPointer << endl; cout << 'Char Address: ' << reinterpret_cast(charPointer)<< endl; return 0; }> Uitvoer
Integer Address: 0x7fff64789f1c Char Address: 0x7fff64789f1c>
In het bovenstaande voorbeeld hebben we een int-variabele gedefinieerd 'nummer' en sla vervolgens het adres van ‘nummer’ op ‘getalwijzer’ van het int-type, daarna hebben we de ‘getalwijzer’ van het int-type in de char-aanwijzer en sla het vervolgens op ‘charPointer’ variabel. Om te verifiëren dat we het adres van zowel numberPointer als charPointer hebben afgedrukt. Om het adres af te drukken dat is opgeslagen in ‘charPointer’ herinterpreteer_cast wordt gebruikt om het typecontrolemechanisme van C++ te omzeilen en ervoor te zorgen dat de aanwijzer wordt afgedrukt als een algemeen geheugenadres zonder enige typespecifieke interpretatie.
Opmerking: const_cast en reinterpret_cast worden over het algemeen niet aanbevolen, omdat ze kwetsbaar zijn voor verschillende soorten fouten.