Liešanas operatori tiek izmantoti tipa liešanai C++ valodā. Tos izmanto, lai pārveidotu vienu datu tipu citā. C++ atbalsta četru veidu apraides:

1. static_cast
2. dinamiskā_apraide
3. const_cast
4. reinterpret_cast

1. static_cast

The static_cast operators ir visbiežāk izmantotais liešanas operators C++. Tas veic kompilēšanas laika tipa pārveidošanu un galvenokārt tiek izmantots tiešiem pārveidojumiem, kurus kompilators uzskata par drošiem.

java vs c++

Static_cast sintakse

  static_cast   <  new_type>(izteiksme);>>
kur,
 
    izteiksme:    Dati, kas jāpārvērš.
    new_type:    Vēlamais izteiksmes veids
Static_cast var izmantot, lai konvertētu starp saistītiem veidiem, piemēram, ciparu tipiem vai norādes tajā pašā mantojuma hierarhijā.
 
    Static_cast piemērs    
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(skaits); // drukāšanas datu tips cout<< typeid(num).name() << endl; // typecasting cout << typeid(static_cast(skaits)).nosaukums()<< endl; // printing double type t cout << typeid(numDouble).name() << endl; return 0; }>
   
  Izvade  Šajā piemērā mēs esam iekļāvuši    tipa informācija    bibliotēku, lai mēs varētu to izmantot    typeid()    funkcija, lai pārbaudītu datu tipu. Mēs esam definējuši veselu skaitļu mainīgo “num” un pārveidojuši to dubultā, izmantojot static_cast. Pēc tam mēs izdrukājam mainīgo datu tipus un nododam    statiskā_apraide(skaits)    iekšā    typeid()    funkciju, lai pārbaudītu tā datu tipu. mēs varam redzēt izvadi i, d, d ir izdrukāts kur    ‘es’    apzīmē    vesels skaitlis    un    ‘d’    apzīmē    dubultā    .
 
 

 
2. dynamic_cast
The dinamiskā_apraide operators galvenokārt tiek izmantots, lai veiktu lejupslīdi (pārveidojot bāzes klases rādītāju/atsauci par atvasinātu klasi). Tas nodrošina tipa drošību, veicot izpildlaika pārbaudi, lai pārbaudītu konvertēšanas derīgumu.
 
Dynamic_cast sintakse
  dynamic_cast   <  new_type>(izteiksme);>>
Ja konvertēšana nav iespējama,    dinamiskā_apraide    atgriežas a    nulles rādītājs    (rādītāja konvertēšanai) vai met a    bad_cast izņēmums    (atsauces reklāmguvumiem).
 
    Dynamic_cast piemērs    
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(dzīvnieku Ptr); // pārbauda, ​​vai tipa apraide ir veiksmīga if (dogPtr) { dogPtr->speak(); } cits { cout<< 'Failed to cast to Dog.' << endl; } // typecasting to other dervied class Cat* catPtr = dynamic_cast(dzīvnieku Ptr); if (catPtr) { catPtr-> runāt(); } cits { cout<< 'Failed to cast to Cat.' << endl; } delete animalPtr; return 0; }>
   
  Izvade      Paskaidrojums:    Pirmā izvades rinda tiek drukāta, jo    'animalPtr'    no    'Dzīvnieks'    tips ir veiksmīgi pārsūtīts uz    'Suns'    veids un    runāt ()    tiek izmantota suņu klases funkcija, bet tiek izmantota    'Dzīvnieks'    ierakstiet uz    'Kaķis'    veids neizdevās, jo    'animalPtr'    norāda uz a    'Suns'    Tādējādi dinamiskā apraide neizdodas, jo tipa apraide nav droša.
 
 

mest izņēmumu apstrādi java
 
3. const_cast
The     const_cast     operators tiek izmantots, lai modificētu mainīgā lieluma const vai nepastāvīgo kvalifikatoru. Tas ļauj programmētājiem uz laiku noņemt objekta noturību un veikt izmaiņas. Lietojot const_cast, jāievēro piesardzība, jo objekta const modificēšana var izraisīt nedefinētu darbību.
 
    Const_cast sintakse    
  const_cast   <  new_type>(izteiksme);>>
    Const_cast piemērs    
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; }>
   
  Izvade  Iepriekš minētajā piemērā mēs esam mainījuši vērtību    const veids    rādītājs, mainot tā kvalifikatoru no    konst    uz    nekonst    un pēc tam izdrukājiet modificēto vērtību.
 
4. reinterpret_cast
The reinterpret_cast operators tiek izmantots, lai pārvērstu rādītāju par jebkura cita veida rādītāju. Tas neveic nekādu pārbaudi, vai konvertētais rādītājs ir tāda paša veida vai nē.
 
    Reinterpret_cast sintakse    
  reinterpret_cast   <  new_type>(izteiksme);>>
    Piemērs    
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(numberPointer); // Atmiņas adrešu un vērtību drukāšana cout<< 'Integer Address: ' << numberPointer << endl; cout << 'Char Address: ' << reinterpret_cast(charPointer)<< endl; return 0; }>
   
  Izvade  Iepriekš minētajā piemērā mēs esam definējuši int mainīgo    'numurs'    un pēc tam saglabājiet “numura” adresi    'numura rādītājs'    int tipa pēc tam esam konvertējuši    'numura rādītājs'    int tipa char rādītājā un pēc tam saglabājiet to    ‘charpointer’    mainīgs. Lai pārbaudītu, vai esam izdrukājuši gan numberPointer, gan charPointer adresi. Lai izdrukātu 'charPointer' saglabāto adresi    reinterpret_cast    tiek izmantots, lai apietu C++ tipa pārbaudes mehānismu un ļautu rādītāja drukāšanai kā vispārējai atmiņas adresei bez tipa specifiskas interpretācijas.
  
    Piezīme:    Const_cast un reinterpret_cast parasti nav ieteicami, jo tie ir neaizsargāti pret dažāda veida kļūdām.