En aquesta secció es parlarà del tipus de càsting de les variables en el llenguatge de programació C++. El càsting de tipus es refereix a la conversió d'un tipus de dades a un altre en un programa. El typecasting es pot fer de dues maneres: automàticament pel compilador i manualment pel programador o usuari. Type Casting també es coneix com a conversió de tipus.

Per exemple, suposem que les dades donades són de tipus enter i volem convertir-les en tipus flotant. Per tant, hem d'emetre manualment dades int al tipus float, i aquest tipus de càsting s'anomena Type Casting en C++.

 int num = 5; float x; x = float(num); x = 5.0 

2^ndexemple:

 float num = 5.25; int x; x = int(num); Output: 5 

El càsting de tipus es divideix en dos tipus: conversió implícita o càsting de tipus implícit i conversió de tipus explícit o càsting de tipus explícit.

Difusió de tipus implícita o conversió de tipus implícita

• Es coneix com a fosa de tipus automàtic.
• Es va convertir automàticament d'un tipus de dades a un altre sense cap intervenció externa, com ara programador o usuari. Significa que el compilador converteix automàticament un tipus de dades a un altre.
• Tots els tipus de dades s'actualitzen automàticament al tipus més gran sense perdre cap informació.
• Només es pot aplicar en un programa si ambdues variables són compatibles entre si.

 char - sort int -> int -> unsigned int -> long int -> float -> double -> long double, etc. 

Nota: L'emissió de tipus implícita s'ha de fer de tipus de dades més baixos a més alts. En cas contrari, afecta el tipus de dades fonamental, que pot perdre precisió o dades, i el compilador pot mostrar un avís en aquest sentit.

Programa per utilitzar el càsting de tipus implícit en C++

Creem un exemple per demostrar el càsting d'una variable a una altra utilitzant el càsting de tipus implícit en 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; } 

Sortida:

 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 

Al programa anterior, vam declarar una variable de tipus de dades breu x és 200 i una variable entera y. Després d'això, assignem el valor x a la y i, a continuació, el compilador converteix automàticament el valor de dades curt x a la y, que retorna que y és 200.

A les expressions següents, vam declarar que una variable de tipus int num és 20 i la variable de tipus de caràcter ch és 'a', que és equivalent a un valor enter de 97. I després, afegim aquestes dues variables per realitzar la conversió implícita, que retorna el resultat de l'expressió és 117.

De la mateixa manera, a la tercera expressió, afegim la variable entera num és 20 i la variable de caràcter ch és 65, i després assignem el resultat a la variable flotant val. Així, el compilador converteix automàticament el resultat de l'expressió al tipus flotant.

Emissió de tipus explícit o conversió de tipus explícit

• També es coneix com a llançament de tipus manual en un programa.
• El programador o l'usuari l'emet manualment per canviar d'un tipus de dades a un altre tipus en un programa. Significa que un usuari pot transmetre fàcilment una dada a una altra segons els requisits d'un programa.
• No requereix comprovar la compatibilitat de les variables.
• En aquest càsting, podem actualitzar o rebaixar el tipus de dades d'una variable a una altra en un programa.
• Utilitza l'operador cast () per canviar el tipus d'una variable.

Sintaxi del tipus de càsting explícit

 (type) expression; 

tipus: Representa les dades definides per l'usuari que converteixen l'expressió donada.

matriu ordenada en java

expressió: Representa el valor constant, la variable o una expressió el tipus de dades de la qual es converteix.

Per exemple, tenim un nombre amb punt flotant és 4,534, i per convertir un valor enter, la declaració com:

 int num; num = (int) 4.534; // cast into int data type cout << num; 

Quan s'executen les declaracions anteriors, el valor de coma flotant es convertirà en un tipus de dades enter mitjançant l'operador cast (). I el valor flotant s'assigna a un nombre enter que trunca la part decimal i només mostra 4 com a valor enter.

Programa per demostrar l'ús del tipus de càsting explícit en C++

Creem un programa senzill per emetre una variable de tipus a un altre tipus utilitzant la distribució de tipus explícita en el llenguatge de programació 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; } 

Sortida:

 Implicit Type Casting: Result: 4 Explicit Type Casting: The value of float variable (res): 4.2 

Al programa anterior, prenem dues variables senceres, a i b, els valors de les quals són 21 i 2. I després, dividiu a per b (21/2) que retorna un valor de tipus 4 int.

A la segona expressió, declarem una variable de tipus flotant res que emmagatzema els resultats de a i b sense perdre cap dada utilitzant l'operador cast en el mètode de cast de tipus explícit.

Programa per emetre dades dobles en tipus int i float mitjançant l'operador cast

Considerem un exemple per obtenir l'àrea del rectangle llançant dades dobles en tipus float i int en programació 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; } 

Sortida:

 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 

Alguns tipus diferents del tipus Casting

En el tipus cast, hi ha un operador de cast que obliga un tipus de dades a convertir-se en un altre tipus de dades segons les necessitats del programa. C++ té quatre tipus diferents d'operador d'emissió:

1. Cast_estàtic
2. dynamic_cast
3. const_cast
4. reinterpretar_cast

Cast estàtic:

El static_cast és una emissió simple en temps de compilació que converteix o emet un tipus de dades a un altre. Vol dir que no comprova el tipus de dades en temps d'execució si l'emissió realitzada és vàlida o no. Així, el programador o l'usuari té la responsabilitat de garantir que la conversió sigui segura i vàlida.

El static_cast és prou capaç de realitzar totes les conversions realitzades pel cast implícit. I també realitza les conversions entre punters de classes relacionades entre si (upcast -> de derivada a classe base o downcast -> de base a classe derivada).

Sintaxi del Cast estàtic

 static_cast (expression); 

Programa per demostrar l'ús del Cast estàtic

Creem un exemple senzill per utilitzar el model estàtic del tipus de càsting a la programació 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; } 

Sortida:

 Before using the static cast: The value of l = 39.375 After using the static cast: The value of tot = 39 

Cast dinàmic

El dynamic_cast és un operador d'emissió en temps d'execució que s'utilitza per realitzar la conversió d'una variable de tipus a una altra només en punters i referències de classe. Vol dir que comprova el càsting vàlid de les variables en temps d'execució i, si el càsting falla, retorna un valor NULL. El càsting dinàmic es basa en el mecanisme RTTI (Runtime Type Identification).

Programa per demostrar l'ús del Dynamic Cast en C++

Creem un programa senzill per realitzar el dynamic_cast en el llenguatge de programació 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'; } } 

Sortida:

 Dynamic casting is done successfully. 

Reinterpreta el tipus d'emissió

L'emissió de tipus reinterpret_cast s'utilitza per llançar un punter a qualsevol altre tipus de punter, tant si el punter donat pertany l'un a l'altre com si no. Vol dir que no comprova si el punter o les dades a les quals apunta és el mateix o no. I també llança un punter a un tipus d'enter o viceversa.

Sintaxi del tipus reinterpretat_cast

 reinterpret_cast expression; 

Programa per utilitzar Reinterpretar Cast en C++

Escrivim un programa per demostrar la conversió d'un punter utilitzant la reinterpretació en llenguatge 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; } 

Sortida:

 The value of pt: 0x5cfed0 The value of ch: A The value of *ptr: 65 The value of *ch: A 

Const Cast

El const_cast s'utilitza per canviar o manipular el comportament const del punter font. Vol dir que podem realitzar la const de dues maneres: establint un punter const a un punter no constant o suprimint o eliminant la const d'un punter const.

Sintaxi del tipus Const Cast

 const_cast exp; 

Programa per utilitzar el Const Cast en C++

Escrivim un programa per llançar un punter d'origen a un punter no emès mitjançant el const_cast en 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; } 

Sortida:

 The value of ptr cast: 500