Gli operatori di cast vengono usati per il casting dei tipi in C++. Vengono utilizzati per convertire un tipo di dati in un altro. C++ supporta quattro tipi di cast:

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

1. cast_statico

IL static_cast L'operatore è l'operatore di cast più comunemente utilizzato in C++. Esegue la conversione del tipo in fase di compilazione e viene utilizzato principalmente per conversioni esplicite considerate sicure dal compilatore.

Sintassi di static_cast

  static_cast   <  new_type>(espressione);>

Dove,

• espressione: Dati da convertire.
• nuovo tipo: Tipo di espressione desiderata

Il static_cast può essere utilizzato per la conversione tra tipi correlati, ad esempio tipi numerici o puntatori nella stessa gerarchia di ereditarietà.

Esempio di static_cast

// 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(numero); // stampa il tipo di dati cout<< typeid(num).name() << endl; // typecasting cout << typeid(static_cast(num)).nome()<< endl; // printing double type t cout << typeid(numDouble).name() << endl; return 0; }>

i d d>

In questo esempio, abbiamo incluso il typeinfo libreria in modo che possiamo usare tipoid() funzione per verificare il tipo di dati. Abbiamo definito una variabile intera 'num' e l'abbiamo convertita in una doppia utilizzando static_cast. Successivamente, stampiamo i tipi di dati delle variabili e passiamo cast_statico(num) In tipoid() funzione per verificare il tipo di dati. possiamo vedere l'output i, d, d viene stampato dove 'io' denota numero intero E 'D' denota Doppio .

2. cast_dinamico

IL Dynamic_cast L'operatore viene utilizzato principalmente per eseguire il downcasting (convertire un puntatore/riferimento di una classe base in una classe derivata). Garantisce l'indipendenza dal tipo eseguendo un controllo di runtime per verificare la validità della conversione.

Sintassi di Dynamic_cast

  dynamic_cast   <  new_type>(espressione);>

Se la conversione non è possibile, Dynamic_cast restituisce a puntatore nullo (per le conversioni dei puntatori) o lancia a eccezione bad_cast (per conversioni di riferimento).

Esempio di Dynamic_cast

// 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(animalePtr); // controlla se il typecasting ha avuto successo if (dogPtr) { dogPtr->speak(); } altro {cout<< 'Failed to cast to Dog.' << endl; } // typecasting to other dervied class Cat* catPtr = dynamic_cast(animalePtr); if (catPtr) { catPtr->parla(); } altro {cout<< 'Failed to cast to Cat.' << endl; } delete animalPtr; return 0; }>

Dog barks. Failed to cast to Cat.>

Spiegazione: La prima riga di output viene stampata perché il file 'animalePtr' del 'Animale' il tipo è stato trasmesso correttamente a 'Cane' tipo e parlare() viene invocata la funzione della classe Dog ma viene invocata la conversione del file 'Animale' digitare a 'Gatto' il tipo non è riuscito perché 'animalePtr' indica a 'Cane' oggetto quindi, il cast dinamico fallisce perché il typecasting non è sicuro.

3. const_cast

IL const_cast L'operatore viene utilizzato per modificare il qualificatore const o volatile di una variabile. Consente ai programmatori di rimuovere temporaneamente la costanza di un oggetto e apportare modifiche. È necessario prestare attenzione quando si utilizza const_cast, poiché la modifica di un oggetto const può portare a un comportamento indefinito.

Sintassi per const_cast

  const_cast   <  new_type>(espressione);>

Esempio di const_cast

// 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; }>

Modified number: 10>

Nell'esempio sopra, abbiamo modificato il valore di tipo const puntatore cambiando il suo qualificatore da cost A non cost e quindi stampando il valore modificato.

4. reinterpret_cast

IL operatore reinterpret_cast viene utilizzato per convertire il puntatore in qualsiasi altro tipo di puntatore. Non esegue alcun controllo se il puntatore convertito è dello stesso tipo oppure no.

Sintassi di reinterpret_cast

  reinterpret_cast   <  new_type>(espressione);>

Esempio

// 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(puntatorenumero); // Stampa gli indirizzi e i valori della memoria cout<< 'Integer Address: ' << numberPointer << endl; cout << 'Char Address: ' << reinterpret_cast(charPointer)<< endl; return 0; }>

Integer Address: 0x7fff64789f1c Char Address: 0x7fff64789f1c>

Nell'esempio precedente, abbiamo definito una variabile int 'numero' e quindi memorizzare l'indirizzo del 'numero' in 'puntatorenumero' del tipo int dopo che abbiamo convertito il file 'numberPointer' del tipo int nel puntatore char e quindi memorizzarlo in 'charPointer' variabile. Per verificare di aver stampato l'indirizzo sia di numberPointer che di charPointer. Per stampare l'indirizzo memorizzato in 'charPointer' reinterpret_cast viene utilizzato per aggirare il meccanismo di controllo del tipo di C++ e consentire la stampa del puntatore come indirizzo di memoria generico senza alcuna interpretazione specifica del tipo.

Nota: const_cast e reinterpret_cast generalmente non sono consigliati poiché sono vulnerabili a diversi tipi di errori.