Liejimo operatoriai naudojami tipo liejimui C++. Jie naudojami vieno tipo duomenų konvertavimui į kitą. C++ palaiko keturių tipų atkūrimą:

1. statinis_perdavimas
2. dinaminis_perdavimas
3. const_cast
4. reinterpret_cast

1. static_cast

The statinis_perdavimas operatorius yra dažniausiai naudojamas liejimo operatorius C++. Jis atlieka kompiliavimo laiko tipo konvertavimą ir daugiausia naudojamas aiškioms konversijoms, kurias kompiliatorius laiko saugiomis.

Static_cast sintaksė

  static_cast    <  new_type>(išraiška);>>  
 kur,  
  
 
    išraiška:     Duomenys, kuriuos reikia konvertuoti.  
 
    new_type:     Pageidaujamas išraiškos tipas  
 
 
 Static_cast gali būti naudojamas konvertuoti tarp susijusių tipų, pvz., skaitinių tipų arba rodyklių toje pačioje paveldėjimo hierarchijoje.  
  
    Static_cast pavyzdys     
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 (skaičius); // spausdinimo duomenų tipas cout < < typeid(num).name()  < < endl; // typecasting cout  < < typeid(static_cast (skaičius)).vardas() < < endl; // printing double type t cout  < < typeid(numDouble).name()  < < endl; return 0; } 
    
  Išvestis    Šiame pavyzdyje įtraukėme     tipo informacija     biblioteka, kad galėtume naudotis     tipoidas ()     funkcija patikrinti duomenų tipą. Mes apibrėžėme sveikojo skaičiaus kintamąjį „num“ ir konvertavome jį į dvigubą, naudodami static_cast. Po to išspausdiname kintamųjų duomenų tipus ir perduodame     statinis_perdavimas(skaičius)     in     tipoidas ()     funkcija patikrinti duomenų tipą. matome kur išspausdinta išvestis i, d, d     'aš'     reiškia     sveikasis skaičius     ir     'd'     reiškia     dvigubai     .  
  
 2. dinaminis_perdavimas  
 
 The   dinaminis_perdavimas   operatorius daugiausia naudojamas atlikti sumažinimą (bazinės klasės rodyklę/nuorodą konvertuoti į išvestinę klasę). Jis užtikrina tipo saugą atlikdamas vykdymo laiko patikrą, kad patikrintų konversijos galiojimą.  
  
 dynamic_cast sintaksė  
 
  dynamic_cast    <  new_type>(išraiška);>>  
 Jei konversija neįmanoma,     dinaminis_perdavimas     grąžina a     nulinis rodyklė     (žymiklio konvertavimui) arba metimai a     bad_cast išimtis     (dėl nuorodų konversijų).  
  
    Dynamic_cast pavyzdys     
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 (gyvūnasPtr); // tikrinama, ar tipo siuntimas sėkmingas if (dogPtr) { dogPtr->speak(); } dar { cout < < 'Failed to cast to Dog.'  < < endl; } // typecasting to other dervied class Cat* catPtr = dynamic_cast (gyvūnasPtr); if (catPtr) { catPtr->speak(); } dar { cout < < 'Failed to cast to Cat.'  < < endl; } delete animalPtr; return 0; } 
    
  Išvestis       Paaiškinimas:     Pirmoji išvesties eilutė išspausdinama, nes     „animalPtr“     iš     'Gyvūnas'     tipas sėkmingai perduotas į     'Šuo'     tipas ir     kalbėti ()     naudojama šunų klasės funkcija, bet išleidžiama     'Gyvūnas'     įveskite į     'Katė'     tipas nepavyko, nes     „animalPtr“     nurodo į a     'Šuo'     Taigi dinaminis atidavimas nepavyksta, nes tipo atkūrimas nėra saugus.  
  
 3. const_cast  
 
 The      const_cast      operatorius naudojamas modifikuoti kintamojo const arba nepastovų kvalifikatorių. Tai leidžia programuotojams laikinai pašalinti objekto pastovumą ir atlikti pakeitimus. Naudodami const_cast reikia būti atsargiems, nes modifikuojant const objektą gali atsirasti neapibrėžtas elgesys.  
  
    Const_cast sintaksė     
 
  const_cast    <  new_type>(išraiška);>>  
    Const_cast pavyzdys     
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; } 
    
  Išvestis    Aukščiau pateiktame pavyzdyje pakeitėme reikšmę     const tipas     žymeklį pakeisdami jo kvalifikatorių iš     konst     į     nekonst     ir tada spausdinama pakeista vertė.  
  
 4. reinterpret_cast  
 
 The   reinterpret_cast operatorius   naudojamas konvertuoti žymeklį į bet kurio kito tipo žymeklį. Ji neatlieka jokio patikrinimo, ar konvertuota rodyklė yra to paties tipo, ar ne.  
  
    Reinterpret_cast sintaksė     
 
  reinterpret_cast    <  new_type>(išraiška);>>  
    Pavyzdys     
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 (numerio rodyklė); // Atminties adresų ir reikšmių spausdinimas cout < < 'Integer Address: '  < < numberPointer  < < endl; cout  < < 'Char Address: '  < < reinterpret_cast (charpointer) < < endl; return 0; } 
    
  Išvestis    Aukščiau pateiktame pavyzdyje apibrėžėme int kintamąjį     'skaičius'     tada išsaugokite „numerio“ adresą     „numerio rodyklė“     int tipo po to konvertavome     'numerio rodyklė'     int tipo į char žymeklį ir išsaugokite jį į     „charpointer“     kintamasis. Norėdami patikrinti, ar išspausdinome ir numberPointer, ir charPointer adresą. Norėdami atspausdinti adresą, saugomą „charPointer“     reinterpret_cast     naudojamas apeiti C++ tipo tikrinimo mechanizmą ir leisti žymeklį spausdinti kaip bendrąjį atminties adresą be jokio tipo aiškinimo.  
  
 
    Pastaba:     const_cast ir reinterpret_cast paprastai nerekomenduojami, nes jie yra pažeidžiami įvairių tipų klaidų.