Støbeoperatorer bruges til typestøbning i C++. De bruges til at konvertere en datatype til en anden. C++ understøtter fire typer casts:

1. static_cast
2. dynamisk_cast
3. const_cast
4. genfortolke_cast

1. static_cast

Det static_cast operator er den mest brugte støbeoperatør i C++. Den udfører kompileringstidstypekonvertering og bruges hovedsageligt til eksplicitte konverteringer, der anses for sikre af compileren.

Syntaks for static_cast

  static_cast   <  new_type>(udtryk);>

hvor,

• udtryk: Data, der skal konverteres.
• ny_type: Ønsket type udtryk

Static_cast kan bruges til at konvertere mellem relaterede typer, såsom numeriske typer eller pointere i det 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(antal); // udskrivning af datatype 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 eksempel har vi inkluderet typeinfo bibliotek, så vi kan bruge typeid() funktion til at kontrollere datatypen. Vi har defineret en heltalsvariabel 'num' og konverteret den til en double ved hjælp af static_cast. Derefter udskriver vi datatyperne for variabler og videregiver static_cast(antal) i typeid() funktion til at kontrollere dens datatype. vi kan se output i, d, d er trykt hvor 'jeg' betegner heltal og 'd' betegner dobbelt .

2. dynamisk_cast

Det dynamisk_cast operator bruges hovedsageligt til at udføre downcasting (konvertering af en pointer/reference for en basisklasse til en afledt klasse). Det sikrer typesikkerhed ved at udføre et runtime-tjek for at verificere gyldigheden af ​​konverteringen.

Syntaks for dynamic_cast

  dynamic_cast   <  new_type>(udtryk);>

Hvis konverteringen ikke er mulig, dynamisk_cast returnerer en nul pointer (til pointerkonverteringer) eller kaster en bad_cast undtagelse (til referencekonverteringer).

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

Dog barks. Failed to cast to Cat.>

Forklaring: Den første linje af output udskrives, fordi 'animalPtr' af 'Dyr' type er castet til 'Hund' type og tale() Hund-klassens funktion påberåbes, men castingen af 'Dyr' skriv til 'Kat' typen mislykkedes pga 'animalPtr' peger på en 'Hund' objektet, således mislykkes den dynamiske cast, fordi typecasting ikke er sikker.

3. const_cast

Det const_cast operator bruges til at ændre den konstante eller flygtige kvalifikatoren for en variabel. Det giver programmører mulighed for midlertidigt at fjerne et objekts konstanthed og foretage ændringer. Der skal udvises forsigtighed ved brug af const_cast, da ændring af et const-objekt kan føre til udefineret adfærd.

Syntaks for const_cast

  const_cast   <  new_type>(udtryk);>

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 ovenstående eksempel har vi ændret værdien af const type pointer ved at ændre dens kvalifikation fra konst til ikke-konst og derefter udskrive den ændrede værdi.

4. genfortolke_cast

Det reinterpret_cast operatør bruges til at konvertere markøren til enhver anden type markør. Den udfører ikke nogen kontrol, om den konverterede pointer er af samme type eller ej.

Syntaks for reinterpret_cast

  reinterpret_cast   <  new_type>(udtryk);>

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(numberPointer); // Udskrivning af hukommelsesadresser og værdier cout<< 'Integer Address: ' << numberPointer << endl; cout << 'Char Address: ' << reinterpret_cast(charPointer)<< endl; return 0; }>

Integer Address: 0x7fff64789f1c Char Address: 0x7fff64789f1c>

I ovenstående eksempel har vi defineret en int-variabel 'nummer' og gem derefter adressen på 'nummer' i 'numberPointer' af typen int, efter at vi har konverteret 'numberPointer' af typen int i char pointer og gem den derefter i 'charPointer' variabel. For at bekræfte, at vi har udskrevet adressen på både numberPointer og charPointer. For at udskrive adressen gemt i 'charPointer' genfortolke_cast bruges til at omgå typekontrolmekanismen i C++ og tillade, at markøren udskrives som en generisk hukommelsesadresse uden nogen typespecifik fortolkning.

Bemærk: const_cast og reinterpret_cast anbefales generelt ikke, da de er sårbare over for forskellige slags fejl.