Gjutoperatorer används för typgjutning i C++. De används för att konvertera en datatyp till en annan. C++ stöder fyra typer av casts:

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

1. static_cast

De static_cast operator är den mest använda gjutoperatorn i C++. Den utför konvertering av kompileringstid och används huvudsakligen för explicita konverteringar som anses säkra av kompilatorn.

Syntax för static_cast

  static_cast   <  new_type>(uttryck);>

var,

• uttryck: Data som ska konverteras.
• ny typ: Önskad typ av uttryck

Static_cast kan användas för att konvertera mellan relaterade typer, såsom numeriska typer eller pekare i samma arvshierarki.

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

i d d>

I det här exemplet har vi inkluderat typinfo bibliotek så att vi kan använda typid() funktion för att kontrollera datatypen. Vi har definierat en heltalsvariabel 'num' och omvandlat den till en dubbel med static_cast. Efter det skriver vi ut datatyperna för variabler och skickar static_cast(antal) i typid() funktion för att kontrollera dess datatyp. vi kan se utdata i, d, d skrivs ut var 'jag' betecknar heltal och 'd' betecknar dubbel .

2. dynamic_cast

De dynamic_cast operatorn används huvudsakligen för att utföra nedsändning (konvertera en pekare/referens för en basklass till en härledd klass). Den säkerställer typsäkerhet genom att utföra en körtidskontroll för att verifiera omvandlingens giltighet.

Syntax för dynamic_cast

  dynamic_cast   <  new_type>(uttryck);>

Om konverteringen inte är möjlig, dynamic_cast returnerar a nollpekare (för pekaromvandlingar) eller kastar en bad_cast undantag (för referenskonverteringar).

Exempel 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(djurPtr); // kontrollerar om typcasting är framgångsrik if (dogPtr) { dogPtr->speak(); } annat { cout<< 'Failed to cast to Dog.' << endl; } // typecasting to other dervied class Cat* catPtr = dynamic_cast(djurPtr); if (catPtr) { catPtr->speak(); } annat { cout<< 'Failed to cast to Cat.' << endl; } delete animalPtr; return 0; }>

Dog barks. Failed to cast to Cat.>

Förklaring: Den första utdataraden skrivs ut eftersom 'animalPtr' av 'Djur' typ har castats till 'Hund' typ och tala() funktion av klassen Hund åberopas men casting av 'Djur' typ till 'Katt' typ misslyckades pga 'animalPtr' pekar på en 'Hund' objektet så misslyckas den dynamiska casten eftersom typcastingen inte är säker.

3. const_cast

De const_cast operator används för att modifiera const eller volatile qualifier för en variabel. Det tillåter programmerare att tillfälligt ta bort ett objekts beständighet och göra ändringar. Försiktighet måste iakttas när du använder const_cast, eftersom modifiering av ett const-objekt kan leda till odefinierat beteende.

Syntax för const_cast

  const_cast   <  new_type>(uttryck);>

Exempel 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 exemplet ovan har vi ändrat värdet på const typ pekare genom att ändra dess kvalificering från konst till icke-konst och sedan skriva ut det ändrade värdet.

4. reinterpret_cast

De reinterpret_cast-operator används för att konvertera pekaren till någon annan typ av pekare. Den utför ingen kontroll om den konverterade pekaren är av samma typ eller inte.

Syntax för reinterpret_cast

  reinterpret_cast   <  new_type>(uttryck);>

Exempel

// 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); // Skriver ut minnesadresser och värden cout<< 'Integer Address: ' << numberPointer << endl; cout << 'Char Address: ' << reinterpret_cast(charPointer)<< endl; return 0; }>

Integer Address: 0x7fff64789f1c Char Address: 0x7fff64789f1c>

I exemplet ovan har vi definierat en int-variabel 'siffra' och lagra sedan adressen till 'nummer' i 'numberPointer' av typen int efter det har vi konverterat 'numberPointer' av typen int i char-pekaren och lagra den sedan i 'charPointer' variabel. För att verifiera att vi har skrivit ut adressen till både numberPointer och charPointer. För att skriva ut adressen lagrad i 'charPointer' reinterpret_cast används för att kringgå typkontrollmekanismen i C++ och tillåta pekaren att skrivas ut som en generisk minnesadress utan någon typspecifik tolkning.

Notera: const_cast och reinterpret_cast rekommenderas i allmänhet inte eftersom de är sårbara för olika typer av fel.