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.
mylivericket
 
    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ų.