Questa sezione discuterà la conversione del tipo delle variabili nel linguaggio di programmazione C++. Il casting del tipo si riferisce alla conversione di un tipo di dati in un altro in un programma. Il typecasting può essere eseguito in due modi: automaticamente dal compilatore e manualmente dal programmatore o dall'utente. Il casting del tipo è noto anche come conversione del tipo.
Ad esempio, supponiamo che i dati forniti siano di tipo intero e desideriamo convertirli in tipo float. Pertanto, dobbiamo eseguire manualmente il cast dei dati int sul tipo float e questo tipo di casting è chiamato Type Casting in C++.
int num = 5; float x; x = float(num); x = 5.0
2ndesempio:
ordinamento delle bolle
float num = 5.25; int x; x = int(num); Output: 5
Il cast del tipo è diviso in due tipi: conversione implicita o cast del tipo implicito e conversione del tipo esplicito o cast del tipo esplicito.
Casting di tipo implicito o conversione di tipo implicita
- È noto come fusione di tipo automatico.
- Viene convertito automaticamente da un tipo di dati a un altro senza alcun intervento esterno come programmatore o utente. Significa che il compilatore converte automaticamente un tipo di dati in un altro.
- Tutti i tipi di dati vengono automaticamente aggiornati al tipo più grande senza perdere alcuna informazione.
- Può applicarsi in un programma solo se entrambe le variabili sono compatibili tra loro.
char - sort int -> int -> unsigned int -> long int -> float -> double -> long double, etc.
Nota: il casting implicito dei tipi deve essere eseguito dai tipi di dati più bassi a quelli più elevati. In caso contrario, influisce sul tipo di dati fondamentale, che potrebbe perdere precisione o dati, e il compilatore potrebbe visualizzare un avviso in tal senso.
Programma per utilizzare il cast di tipo implicito in C++
Creiamo un esempio per dimostrare il casting di una variabile a un'altra utilizzando il cast di tipo implicito in C++.
#include using namespace std; int main () { short x = 200; int y; y = x; cout << ' Implicit Type Casting ' << endl; cout << ' The value of x: ' << x << endl; cout << ' The value of y: ' << y << endl; int num = 20; char ch = 'a'; int res = 20 + 'a'; cout << ' Type casting char to int data type ('a' to 20): ' << res << endl; float val = num + 'A'; cout << ' Type casting from int data to float type: ' << val << endl; return 0; } Produzione:
Implicit Type Casting The value of x: 200 The value of y: 200 Type casting char to int data type ('a' to 20): 117 Type casting from int data to float type: 85
Nel programma sopra, abbiamo dichiarato una variabile di tipo dati breve x è 200 e una variabile intera y. Successivamente, assegniamo il valore x a y, quindi il compilatore converte automaticamente il valore dei dati brevi x in y, che restituisce y è 200.
Nelle espressioni successive, abbiamo dichiarato una variabile di tipo int num è 20 e la variabile di tipo carattere ch è 'a', che equivale a un valore intero di 97. Quindi aggiungiamo queste due variabili per eseguire la conversione implicita, che restituisce il risultato dell'espressione è 117.
Allo stesso modo, nella terza espressione, aggiungiamo la variabile intera num è 20 e la variabile di carattere ch è 65, quindi assegniamo il risultato alla variabile float val. Pertanto il risultato dell'espressione viene automaticamente convertito nel tipo float dal compilatore.
Casting di tipo esplicito o conversione di tipo esplicito
- È noto anche come casting di tipo manuale in un programma.
- Viene lanciato manualmente dal programmatore o dall'utente per passare da un tipo di dati a un altro in un programma. Significa che un utente può facilmente trasmettere un dato a un altro in base ai requisiti di un programma.
- Non è necessario verificare la compatibilità delle variabili.
- In questo casting possiamo aggiornare o declassare il tipo di dati di una variabile a un'altra in un programma.
- Utilizza l'operatore cast() per modificare il tipo di una variabile.
Sintassi del casting di tipo esplicito
(type) expression;
tipo: Rappresenta i dati definiti dall'utente che convertono l'espressione data.
espressione: Rappresenta il valore costante, la variabile o un'espressione il cui tipo di dati viene convertito.
Ad esempio, abbiamo un numero a virgola mobile è 4.534 e per convertire un valore intero, l'istruzione come:
int num; num = (int) 4.534; // cast into int data type cout << num;
Quando vengono eseguite le istruzioni precedenti, il valore a virgola mobile verrà convertito in un tipo di dati intero utilizzando l'operatore cast (). E il valore float viene assegnato a un numero intero che tronca la parte decimale e visualizza solo 4 come valore intero.
Programma per dimostrare l'uso del cast esplicito del tipo in C++
b+ alberi
Creiamo un semplice programma per eseguire il cast di una variabile di tipo in un altro tipo utilizzando il casting di tipo esplicito nel linguaggio di programmazione C++.
#include using namespace std; int main () { // declaration of the variables int a, b; float res; a = 21; b = 5; cout << ' Implicit Type Casting: ' << endl; cout << ' Result: ' << a / b << endl; // it loses some information cout << '
Explicit Type Casting: ' << endl; // use cast () operator to convert int data to float res = (float) 21 / 5; cout << ' The value of float variable (res): ' << res << endl; return 0; } Produzione:
Implicit Type Casting: Result: 4 Explicit Type Casting: The value of float variable (res): 4.2
Nel programma sopra, prendiamo due variabili intere, a e b, i cui valori sono 21 e 2. Quindi dividiamo a per b (21/2) che restituisce un valore di tipo 4 int.
Nella seconda espressione, dichiariamo una variabile di tipo float res che memorizza i risultati di a e b senza perdere alcun dato utilizzando l'operatore cast nel metodo cast di tipo esplicito.
Programma per eseguire il cast di double data nei tipi int e float utilizzando l'operatore cast
Consideriamo un esempio per ottenere l'area del rettangolo trasformando i dati double nei tipi float e int nella programmazione C++.
#include using namespace std; int main () { // declaration of the variables double l, b; int area; // convert double data type to int type cout << ' The length of the rectangle is: ' <> l; cout << ' The breadth of the rectangle is: ' <> b; area = (int) l * b; // cast into int type cout << ' The area of the rectangle is: ' << area << endl; float res; // convert double data type to float type cout << '
The length of the rectangle is: ' << l << endl; cout << ' The breadth of the rectangle is: ' << b << endl; res = (float) l * b; // cast into float type cout << ' The area of the rectangle is: ' << res; return 0; } Produzione:
The length of the rectangle is: 57.3456 The breadth of the rectangle is: 12.9874 The area of the rectangle is: 740 The length of the rectangle is: 57.3456 The breadth of the rectangle is: 12.9874 The area of the rectangle is: 744.77
Alcuni diversi tipi di Type Casting
Nel cast di tipo, è presente un operatore cast che forza la conversione di un tipo di dati in un altro tipo di dati in base alle esigenze del programma. Il C++ ha quattro diversi tipi di operatore cast:
- Cast_statico
- Dynamic_cast
- const_cast
- reinterpret_cast
Cast statico:
static_cast è un semplice cast in fase di compilazione che converte o trasmette un tipo di dati a un altro. Significa che non controlla il tipo di dati in fase di esecuzione se il cast eseguito è valido o meno. Pertanto il programmatore o l'utente ha la responsabilità di garantire che la conversione sia sicura e valida.
Il static_cast è sufficientemente capace da poter eseguire tutte le conversioni effettuate dal cast implicito. Ed esegue anche le conversioni tra puntatori di classi correlate tra loro (upcast -> da classe derivata a base o downcast -> da classe base a derivata).
Sintassi del cast statico
static_cast (expression);
Programma per dimostrare l'uso dello Static Cast
Creiamo un semplice esempio per utilizzare il cast statico del tipo casting nella programmazione C++.
#include using namespace std; int main () { // declare a variable double l; l = 2.5 * 3.5 * 4.5; int tot; cout << ' Before using the static cast:' << endl; cout << ' The value of l = ' << l << endl; // use the static_cast to convert the data type tot = static_cast (l); cout << ' After using the static cast: ' << endl; cout << ' The value of tot = ' << tot << endl; return 0; } Produzione:
Before using the static cast: The value of l = 39.375 After using the static cast: The value of tot = 39
Cast dinamico
Dynamic_cast è un operatore cast di runtime utilizzato per eseguire la conversione di una variabile di tipo in un'altra solo su puntatori e riferimenti di classe. Significa che controlla il casting valido delle variabili in fase di esecuzione e, se il casting fallisce, restituisce un valore NULL. Il casting dinamico si basa sul meccanismo RTTI (Runtime Type Identification).
Programma per dimostrare l'uso del Dynamic Cast in C++
Creiamo un semplice programma per eseguire il Dynamic_cast nel linguaggio di programmazione C++.
#include using namespace std; class parent { public: virtual void print() { } }; class derived: public parent { }; int main () { // create an object ptr parent *ptr = new derived; // use the dynamic cast to convert class data derived* d = dynamic_cast (ptr); // check whether the dynamic cast is performed or not if ( d != NULL) { cout << ' Dynamic casting is done successfully'; } else { cout << ' Dynamic casting is not done successfully'; } } Produzione:
Dynamic casting is done successfully.
Reinterpretare il tipo di cast
Il casting del tipo reinterpret_cast viene utilizzato per trasmettere un puntatore a qualsiasi altro tipo di puntatore indipendentemente dal fatto che i puntatori indicati appartengano o meno all'altro. Significa che non controlla se il puntatore o i dati puntati dal puntatore sono gli stessi o meno. E lancia anche un puntatore a un tipo intero o viceversa.
Sintassi del tipo reinterpret_cast
reinterpret_cast expression;
Programma per utilizzare Reinterpret Cast in C++
Scriviamo un programma per dimostrare la conversione di un puntatore utilizzando la reinterpretazione in linguaggio C++.
#include using namespace std; int main () { // declaration of the pointer variables int *pt = new int (65); // use reinterpre_cast operator to type cast the pointer variables char *ch = reinterpret_cast (pt); cout << ' The value of pt: ' << pt << endl; cout << ' The value of ch: ' << ch << endl; // get value of the defined variable using pointer cout << ' The value of *ptr: ' << *pt << endl; cout << ' The value of *ch: ' << *ch << endl; return 0; } Produzione:
The value of pt: 0x5cfed0 The value of ch: A The value of *ptr: 65 The value of *ch: A
Cast costante
const_cast viene utilizzato per modificare o manipolare il comportamento const del puntatore sorgente. Significa che possiamo eseguire const in due modi: impostando un puntatore const su un puntatore non const o eliminando o rimuovendo const da un puntatore const.
Sintassi del tipo Const Cast
programma a matrice in linguaggio c
const_cast exp;
Programma per utilizzare Const Cast in C++
Scriviamo un programma per eseguire il cast di un puntatore sorgente su un puntatore non cast utilizzando const_cast in C++.
#include using namespace std; // define a function int disp(int *pt) { return (*pt * 10); } int main () { // declare a const variable const int num = 50; const int *pt = # // get the address of num // use const_cast to chnage the constness of the source pointer int *ptr = const_cast (pt); cout << ' The value of ptr cast: ' << disp(ptr); return 0; } Produzione:
The value of ptr cast: 500