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:

nick pulos llamp negre

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).
matemàtiques aleatòries java aleatòries
 
    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.