Operatorii de turnare sunt utilizați pentru turnarea tipului în C++. Sunt folosite pentru a converti un tip de date în altul. C++ acceptă patru tipuri de turnări:

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

1. static_cast

The static_cast operatorul este cel mai frecvent utilizat operator de turnare în C++. Efectuează conversie de tip în timp de compilare și este utilizat în principal pentru conversii explicite care sunt considerate sigure de către compilator.

Sintaxa lui static_cast

  static_cast   <  new_type>(expresie);>>>
Unde,
 
    expresie:    Date de convertit.
    tip nou:    Tipul de expresie dorit
static_cast poate fi folosit pentru a converti între tipuri înrudite, cum ar fi tipuri numerice sau pointeri în aceeași ierarhie de moștenire.
convertiți șirul în int
 
    Exemplu de static_cast    
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(num); // tipărirea datelor de tip cout<< typeid(num).name() << endl; // typecasting cout << typeid(static_cast(num)).nume()<< endl; // printing double type t cout << typeid(numDouble).name() << endl; return 0; }>
   
  Ieșire  În acest exemplu, am inclus    tipinfo    bibliotecă astfel încât să putem folosi    typeid()    funcția de verificare a tipului de date. Am definit o variabilă întreagă „num” și am convertit-o într-o dublă folosind static_cast. După aceea, imprimăm tipurile de date ale variabilelor și trecem    static_cast(num)    în    typeid()    funcția de verificare a tipului de date. putem vedea ieșirea i, d, d este tipărită unde    ‘eu’    denotă    întreg    și    ‘d’    denotă    dubla    .
 
 

 
2. dynamic_cast
The dynamic_cast operatorul este utilizat în principal pentru a efectua downcasting (conversia unui pointer/referință a unei clase de bază într-o clasă derivată). Asigură siguranța tipului prin efectuarea unei verificări de rulare pentru a verifica validitatea conversiei.
dacă altceva în shell bash
 
Sintaxa lui dynamic_cast
  dynamic_cast   <  new_type>(expresie);>>>
Dacă conversia nu este posibilă,    dynamic_cast    întoarce a    indicator nul    (pentru conversii pointer) sau aruncă a    excepție bad_cast    (pentru conversii de referință).
 
    Exemplu de dynamic_cast    
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(animalPtr); // verifică dacă tipărirea este reușită if (dogPtr) { dogPtr->speak(); } else { cout<< 'Failed to cast to Dog.' << endl; } // typecasting to other dervied class Cat* catPtr = dynamic_cast(animalPtr); if (catPtr) { catPtr->vorbește(); } else { cout<< 'Failed to cast to Cat.' << endl; } delete animalPtr; return 0; }>
   
  Ieșire      Explicaţie:    Prima linie de ieșire este tipărită deoarece    „animalPtr”    al    'Animal'    tipul este transmis cu succes la    'Câine'    tip și    vorbi()    funcția clasei Dog este invocată dar turnarea lui    'Animal'    tastați să    'Pisică'    tipul este eșuat deoarece    „animalPtr”    indică a    'Câine'    obiect astfel, distribuția dinamică eșuează deoarece tiparea nu este sigură.
 
 

 
3. const_cast
The     const_cast     operator este folosit pentru a modifica calificativul const sau volatil al unei variabile. Permite programatorilor să elimine temporar constanța unui obiect și să facă modificări. Trebuie avut grijă când utilizați const_cast, deoarece modificarea unui obiect const poate duce la un comportament nedefinit.
 
    Sintaxă pentru const_cast    
  const_cast   <  new_type>(expresie);>>>
    Exemplu de const_cast    
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; }>
   
  Ieșire  În exemplul de mai sus, am modificat valoarea lui    tip const    pointer schimbându-i calificativul din    const    la    non-const    apoi imprimarea valorii modificate.
 
4. reinterpret_cast
The operator reinterpret_cast este folosit pentru a converti indicatorul în orice alt tip de indicator. Nu efectuează nicio verificare dacă pointerul convertit este de același tip sau nu.
parsing string la int
 
    Sintaxa lui reinterpret_cast    
  reinterpret_cast   <  new_type>(expresie);>>>
    Exemplu    
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); // Imprimarea adreselor de memorie și a valorilor cout<< 'Integer Address: ' << numberPointer << endl; cout << 'Char Address: ' << reinterpret_cast(charPointer)<< endl; return 0; }>
   
  Ieșire  În exemplul de mai sus, am definit o variabilă int    'număr'    și apoi stocați adresa „numărului” în    „numberPointer”    de tip int după aceea am convertit    „numberPointer”    de tip int în indicatorul char și apoi stocați-l în    „charPointer”    variabil. Pentru a verifica dacă am tipărit adresa atât pentru numberPointer, cât și pentru charPointer. Pentru a imprima adresa stocată în „charPointer”    reinterpret_cast    este folosit pentru a ocoli mecanismul de verificare a tipului din C++ și pentru a permite tipărirea indicatorului ca o adresă de memorie generică fără nicio interpretare specifică tipului.
  
    Notă:    const_cast și reinterpret_cast nu sunt, în general, recomandate, deoarece sunt vulnerabile la diferite tipuri de erori.