Els operadors de càsting s'utilitzen per al càsting de tipus en C++. S'utilitzen per convertir un tipus de dades a un altre. C++ admet quatre tipus de càlculs:

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

1. static_cast

El static_cast operador és l'operador de càsting més utilitzat en C++. Realitza una conversió de tipus en temps de compilació i s'utilitza principalment per a conversions explícites que el compilador considera segures.

Sintaxi de static_cast

  static_cast    <  new_type>(expressió);>>>  
 on,  
  
 
    expressió:     Dades a convertir.  
 
    nou_tipus:     Tipus d'expressió desitjat  
 
 
 El static_cast es pot utilitzar per convertir entre tipus relacionats, com ara tipus numèrics o punters a la mateixa jerarquia d'herència.  
  
    Exemple 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 (núm); // imprimint el tipus de dades cout < < typeid(num).name()  < < endl; // typecasting cout  < < typeid(static_cast (número)).nom() < < endl; // printing double type t cout  < < typeid(numDouble).name()  < < endl; return 0; } 
    
  Sortida    En aquest exemple, hem inclòs el     informació tipus     biblioteca perquè puguem utilitzar     typeid()     funció per comprovar el tipus de dades. Hem definit una variable entera 'num' i l'hem convertit en doble mitjançant static_cast. Després d'això, imprimim els tipus de dades de les variables i passem     static_cast(número)     en     typeid()     funció per comprovar el seu tipus de dades. podem veure on s'imprimeix la sortida i, d, d     'jo'     denota     enter     i     'd'     denota     doble     .  
  
 2. dynamic_cast  
 
 El   dynamic_cast   L'operador s'utilitza principalment per realitzar downcasting (convertir un punter/referència d'una classe base en una classe derivada). Assegura la seguretat del tipus realitzant una comprovació en temps d'execució per verificar la validesa de la conversió.  
  
 Sintaxi de dynamic_cast  
 
  dynamic_cast    <  new_type>(expressió);>>>  
 Si la conversió no és possible,     dynamic_cast     torna a     punter nul     (per a conversions de punter) o llança a     excepció bad_cast     (per a conversions de referència).  
  
    Exemple 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); // comprovant si el typecasting és correcte 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->parla(); } else { cout < < 'Failed to cast to Cat.'  < < endl; } delete animalPtr; return 0; } 
    
  Sortida       Explicació:     La primera línia de sortida s'imprimeix perquè     'animalPtr'     del     'Animal'     tipus s'ha llançat correctament a     'Gos'     tipus i     parlar ()     s'invoca la funció de la classe Dog però el càsting de la     'Animal'     escriviu a     'Gat'     El tipus ha fallat perquè     'animalPtr'     apunta a a     'Gos'     objecte, per tant, la distribució dinàmica falla perquè l'emissió de tipus no és segura.  
  
 3. const_cast  
 
 El      const_cast      L'operador s'utilitza per modificar el qualificador const o volàtil d'una variable. Permet als programadors eliminar temporalment la constància d'un objecte i fer modificacions. S'ha de tenir precaució quan s'utilitza const_cast, ja que modificar un objecte const pot provocar un comportament no definit.  
  
    Sintaxi per const_cast     
 
  const_cast    <  new_type>(expressió);>>>  
    Exemple 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; } 
    
  Sortida    A l'exemple anterior, hem modificat el valor de la     tipus const     punter canviant el seu qualificador de     const     a     no const     i després imprimint el valor modificat.  
  
 4. reinterpretar_cast  
 
 El   operador reinterpretat_cast   s'utilitza per convertir el punter a qualsevol altre tipus de punter. No realitza cap comprovació de si el punter convertit és del mateix tipus o no.  
  
    Sintaxi de reinterpretar_cast     
 
  reinterpret_cast    <  new_type>(expressió);>>>  
    Exemple     
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 (númeroApuntador); // Imprimeix les adreces de memòria i els valors cout < < 'Integer Address: '  < < numberPointer  < < endl; cout  < < 'Char Address: '  < < reinterpret_cast (charPointer) < < endl; return 0; } 
    
  Sortida    A l'exemple anterior, hem definit una variable int     'nombre'     i després deseu l'adreça del 'número' a     'numberPointer'     del tipus int després d'haver convertit el     'numberPointer'     del tipus int al punter de caràcters i després emmagatzemar-lo a     'charPointer'     variable. Per verificar que hem imprès l'adreça de numberPointer i charPointer. Per imprimir l'adreça emmagatzemada a 'charPointer'     reinterpretar_cast     s'utilitza per evitar el mecanisme de verificació de tipus de C++ i permetre que el punter s'imprimi com una adreça de memòria genèrica sense cap interpretació específica del tipus.  
  
 
    Nota:     const_cast i reinterpret_cast generalment no es recomanen, ja que són vulnerables a diferents tipus d'errors.