Støpeoperatører brukes til typestøping i C++. De brukes til å konvertere en datatype til en annen. C++ støtter fire typer cast:

1. static_cast
2. dynamic_cast
3. const_cast
4. reinterpret_cast

1. static_cast

De static_cast operatør er den mest brukte støpeoperatøren i C++. Den utfører kompileringstidstypekonvertering og brukes hovedsakelig til eksplisitte konverteringer som anses som trygge av kompilatoren.

Syntaks for static_cast

  static_cast   <  new_type>(uttrykk);>

hvor,

• uttrykk: Data som skal konverteres.
• ny_type: Ønsket type uttrykk

Static_cast kan brukes til å konvertere mellom relaterte typer, for eksempel numeriske typer eller pekere i samme arvehierarki.

Eksempel på static_cast

// 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(antall); // utskriftsdatatype cout<< typeid(num).name() << endl; // typecasting cout << typeid(static_cast(num)).navn()<< endl; // printing double type t cout << typeid(numDouble).name() << endl; return 0; }>

i d d>

I dette eksemplet har vi inkludert typeinfo bibliotek slik at vi kan bruke typeid() funksjon for å sjekke datatypen. Vi har definert en heltallsvariabel 'num' og konvertert den til en dobbel ved å bruke static_cast. Etter det skriver vi ut datatypene for variabler og passerer static_cast(antall) i typeid() funksjon for å sjekke datatypen. vi kan se utgangen i, d, d er skrevet ut hvor 'Jeg' betegner heltall og 'd' betegner dobbelt .

2. dynamic_cast

De dynamic_cast operatør brukes hovedsakelig til å utføre nedkasting (konvertere en peker/referanse til en basisklasse til en avledet klasse). Den sikrer typesikkerhet ved å utføre en kjøretidssjekk for å bekrefte gyldigheten av konverteringen.

Syntaks for dynamic_cast

  dynamic_cast   <  new_type>(uttrykk);>

Hvis konverteringen ikke er mulig, dynamic_cast returnerer en null-peker (for pekerkonverteringer) eller kaster en bad_cast unntak (for referansekonverteringer).

Eksempel på dynamic_cast

// 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(dyrPtr); // sjekker om typecasting er vellykket if (dogPtr) { dogPtr->speak(); } annet { cout<< 'Failed to cast to Dog.' << endl; } // typecasting to other dervied class Cat* catPtr = dynamic_cast(dyrPtr); if (catPtr) { catPtr->speak(); } annet { cout<< 'Failed to cast to Cat.' << endl; } delete animalPtr; return 0; }>

Dog barks. Failed to cast to Cat.>

Forklaring: Den første utskriftslinjen skrives ut fordi 'animalPtr' av 'Dyr' typen er vellykket castet til 'Hund' type og snakke() funksjonen til Dog-klassen påberopes, men casting av 'Dyr' skriv til 'Katt' typen mislyktes fordi 'animalPtr' peker på en 'Hund' objektet dermed mislykkes den dynamiske casten fordi typecasting ikke er sikker.

3. const_cast

De const_cast operator brukes til å modifisere const eller volatile qualifier for en variabel. Det lar programmerere midlertidig fjerne konstantheten til et objekt og gjøre endringer. Forsiktighet må utvises når du bruker const_cast, siden modifisering av et const-objekt kan føre til udefinert atferd.

Syntaks for const_cast

  const_cast   <  new_type>(uttrykk);>

Eksempel på const_cast

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

Modified number: 10>

I eksemplet ovenfor har vi endret verdien av const type pekeren ved å endre kvalifikatoren fra konst til ikke-konst og deretter skrive ut den endrede verdien.

4. reinterpret_cast

De reinterpret_cast-operatør brukes til å konvertere pekeren til en hvilken som helst annen type peker. Den utfører ingen kontroll om den konverterte pekeren er av samme type eller ikke.

Syntaks for reinterpret_cast

  reinterpret_cast   <  new_type>(uttrykk);>

Eksempel

// 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(tallpeker); // Skriver ut minneadresser og verdier cout<< 'Integer Address: ' << numberPointer << endl; cout << 'Char Address: ' << reinterpret_cast(charPointer)<< endl; return 0; }>

Integer Address: 0x7fff64789f1c Char Address: 0x7fff64789f1c>

I eksemplet ovenfor har vi definert en int-variabel 'Antall' og lagre deretter adressen til 'nummer' i 'numberPointer' av typen int etter at vi har konvertert 'numberPointer' av typen int i char pointer og lagre den deretter i 'charPointer' variabel. For å bekrefte at vi har skrevet ut adressen til både numberPointer og charPointer. For å skrive ut adressen som er lagret i 'charPointer' reinterpret_cast brukes til å omgå typekontrollmekanismen til C++ og la pekeren skrives ut som en generisk minneadresse uten noen typespesifikk tolkning.

Merk: const_cast og reinterpret_cast anbefales generelt ikke da de er sårbare for forskjellige typer feil.