Menú

Escriviu conversions en C ++

type conversions c

Proveu El Nostre Instrument Per Eliminar Problemes

Consulteu les diverses conversions de tipus compatibles amb C ++.

Esperem que tingueu en compte tots els tipus de dades disponibles a C ++ dels nostres tutorials anteriors. De vegades, pot sorgir una necessitat que necessitem convertir un tipus a un altre. Això s’anomena conversió de tipus o casting de tipus.

En aquest tutorial, analitzarem les diverses conversions de tipus compatibles amb C ++.

converteix char en int c ++

=> Feu clic aquí per obtenir el curs gratuït de C ++.

Escriviu conversions en C ++

Què aprendreu:

Conversions de tipus

C ++ admet dos tipus de conversions de tipus:

  • Conversió de tipus implícita: La conversió de tipus implícita és automàtica. No hi ha interferències de l'usuari en aquest tipus de conversió i el compilador realitza la conversió directament. La conversió es fa generalment quan en l’expressió hi ha més d’un tipus de dades. Però, generalment, en aquest tipus de conversió, hi ha la possibilitat de pèrdua de dades, pèrdua de signes o desbordament de dades.
  • Conversió de tipus explícita: La conversió de tipus explícita està definida per l'usuari i normalment s'anomena 'casting de tipus'. Aquí l'usuari emet o converteix un valor d'un tipus de dades a un altre en funció dels requisits. Aquest tipus de conversions són més segures.

Ara veurem detalladament els dos tipus de conversió de tipus.

Conversió implícita

En la conversió implícita, el compilador realitza les conversions d’un tipus de dades a un altre sempre que una expressió tingui més d’un tipus de dades. Per evitar la pèrdua de dades, totes les variables dels altres tipus de dades es converteixen al tipus de dades més gran. Això s’anomena promoció.

Comprenguem la conversió implícita mitjançant un exemple de codi.

#include using namespace std; int main() { int num = 10; char ch = 'A'; cout<<'10 + 'A' = '<

float val (10 + 'a') = 107

var_int = 1000

L'exemple de codi anterior mostra una conversió implícita. Hem declarat un enter i una variable de caràcter amb valors 10 i 'A' respectivament. Quan sumem aquestes dues variables, es produeix una conversió implícita.

Com que el nombre enter és el tipus més gran d'aquesta expressió, el valor de la variable de caràcter 'A' es converteix en el seu equivalent enter, és a dir, el valor 65 (valor ASCII). Així, el resultat de l’expressió és 75.

A la següent expressió, afegim un nombre enter i un caràcter («a» -> 97) i després assignem el resultat a flotació. Així, el resultat de l'expressió es converteix implícitament en flotant pel compilador.

A la tercera expressió, una variable int curta es converteix implícitament en enter.

Nota : En cas de conversions implícites, si el compilador detecta una pèrdua potencial de dades, és possible que sembli un advertiment en aquest sentit.

Conversió explícita

La conversió explícita també es coneix com a 'emissió de tipus', ja que 'emetem' un tipus de dades a un altre tipus de dades. Aquí, els usuaris defineixen explícitament el càsting, a diferència de la conversió implícita en què el compilador realitza la conversió internament.

Podem realitzar conversions explícites de dues maneres:

# 1) Ús de l'operador d'assignació

La conversió o tipografia explícita mitjançant l'operador d'assignació es realitza amb força. Aquí emetem o convertim un tipus de dades a un altre tipus de dades mitjançant l'operador d'assignació.

La sintaxi general és:

(data type) expression;

El següent exemple explica això:

crear una matriu de cadenes java
#include #include using namespace std; int main() { int sum; double salary = 4563.75; sum = (int)salary + 1000; cout<<'Sum = '<

Com es mostra a la sortida, el tipus al qual emetem indica el tipus final del resultat de l’expressió.

Això és avantatjós ja que l'usuari pot canviar el tipus d'expressió segons els requisits.

# 2) Ús de Cast Operator

En aquest tipus de càsting, fem servir un 'operador de repartiment' que és un operador unari per canviar d'un tipus a un altre.

Tipus de càsting

Tenim els següents tipus de càsting en funció de l’operador de repartiment que utilitzem:

# 1) Repartiment estàtic

El repartiment estàtic és el més senzill de tots els processos de tipografia mitjançant l’operador de repartiment . El repartiment estàtic pot realitzar totes les conversions que es duen a terme de manera implícita. També realitza conversions entre punters de classes relacionats entre si (ascendit -> de derivat a base o baixat -> de base a derivat).

A part de les conversions esmentades, el repartiment estàtic també pot convertir qualsevol punter a buit *.

El repartiment estàtic és el repartiment de temps compilat. Això significa que no es fa cap comprovació en temps d'execució per veure si el repartiment realitzat és vàlid o no. Per tant, continua sent la responsabilitat del programador assegurar-se que la conversió sigui segura i vàlida.

Dit d’una altra manera, l’usuari s’ha d’assegurar que l’objecte convertit estava ple respecte al tipus de dades de destinació.

Especifiquem un repartiment estàtic de la següent manera:

static_cast (expression)

Comprenem el repartiment estàtic amb un exemple.

#include using namespace std; int main() { double df = 3.5 * 3.5 * 3.5; cout<<'Before casting: df = '<

Ara modificem el codi anterior de la següent manera:

#include using namespace std; int main() { double df = 3.5 * 3.5 * 3.5; cout<<'Before casting :df = '<

A l'exemple anterior, hem modificat lleugerament el codi per incloure una variable de caràcters amb el valor 'A'. A continuació, declarem un punter enter i apliquem un repartiment estàtic per convertir un caràcter en un punter enter.

Quan compilem aquest programa obtenim la següent sortida.

A la funció 'int main ()':
10:35: error: static_cast no vàlid des del tipus 'char *' fins al tipus 'int *'

El programa dóna un error per al repartiment estàtic realitzat perquè no és vàlid. Per tant, el càsting estàtic només permet fer conversions o conversions de tipus vàlides i produeix un error quan intentem dur a terme algunes tipografies no desitjades.

# 2) Repartiment dinàmic

El repartiment dinàmic és un repartiment en temps d'execució realitzat per comprovar la validesa del repartiment. El repartiment dinàmic només es realitza amb indicadors i referències de classe. L'expressió retorna un valor NULL si el repartiment falla.

El repartiment dinàmic utilitza un mecanisme conegut com RTTI (identificació de tipus d'execució) . RTTI fa que tota la informació sobre el tipus de dades de l’objecte estigui disponible en temps d’execució i només està disponible per a les classes que tenen almenys una funció virtual (tipus polimòrfic). RTTI permet determinar el tipus d'objecte en temps d'execució o en el moment de l'execució.

Provem un exemple per entendre el repartiment dinàmic.

#include #include using namespace std; class base {public: virtual void print(){}}; class derived:public base{}; int main() { base* b = new derived; derived* d = dynamic_cast(b); if(d != NULL) cout<<'Dynamic_cast done successfully'; else cout<<'Dynamic_cast not successful'; }

En aquest programa, hem definit dues classes, base amb una funció virtual i derivades que tenen una classe base, base.

A la funció principal, creem un objecte de classe derivat apuntat pel punter de classe base. A continuació, realitzem dynamic_cast al punter base que apunta a una classe derivada per convertir-lo a un punter de classe derivat.

Igual que a la classe base, la base és polimòrfica (conté una funció virtual), elcast_dinàmic té èxit.

Nota: Si eliminem la funció virtual de la classe anterior, aleshores dynamic_cast fallarà ja que la informació RTTI dels objectes no estarà disponible.

El repartiment dinàmic té una sobrecàrrega de seguretat de tipus en temps d'execució.

# 3) Reinterpreteu el repartiment

Aquest tipus de repartiment és més perillós d’utilitzar ja que funciona sobre qualsevol tipus d’objecte sense que les classes estiguin relacionades entre si.

Reintepret_cast funciona amb qualsevol punter i converteix un punter de qualsevol tipus a qualsevol altre tipus, independentment de si els punteres estan relacionats entre si o no. No comprova si el punter o les dades apuntades pel punter són iguals o no.

L'operador d'emissió només pren un paràmetre, el punter d'origen a convertir i no retorna cap valor. Simplement converteix el tipus de punter.

No hauríem d'utilitzar tret que sigui necessari. Normalment tipificem el punter d'origen al seu tipus original.

Solem treballar sobretot amb bits. Quan s’utilitza en valors booleans, els valors booleans es converteixen en valors enters, és a dir, 1 per a cert i 0 per a fals.

Vegem un exemple de repartiment reinterpretat:

#include using namespace std; int main() { int* ptr = new int(97); char* ch = reinterpret_cast(ptr); cout << ptr << endl; cout << ch << endl; cout << *ptr << endl; cout << *ch << endl; return 0; }

Sortida:

0x3ef3090
a
97
a

A l'exemple anterior, hem declarat un punter sencer ptr que apunta al valor 97. A continuació, declarem un punter de caràcters ch i hi fem servir ptr.

A continuació, imprimim diversos valors. El primer que imprimim és ptr que apunta a una ubicació sencera. Per tant, imprimeix una adreça.

El següent valor ch conté el valor 97 i, per tant, imprimeix 'a' que és l'ASCII equivalent a 97. El següent valor '* ptr' manté el valor 97 mentre que '* ch' manté l'ASCII equivalent a 97 és a dir, 'a' mentre es fa servir el reinterpret_cast.

# 4) Const Cast

L'operador de repartiment s'utilitza per canviar o manipular la constància del punter d'origen. Per manipulació, volem dir que es pot establir la constància a un punter que no és const o eliminar una constància d’un punter de const.

La condició per transmetre amb èxit l’operador és que el punter i la font que s’emet són del mateix tipus.

programari per descarregar vídeo des de qualsevol lloc web

Prenguem un exemple per entendre-ho.

#include using namespace std; int printVal(int* ptr) { return(*ptr*10); } int main(void) { const int value = 10; const int *ptr = &value; int *ptr_cast = const_cast (ptr); cout <<'printVal returned = '<< printVal(ptr_cast); return 0; }

En aquest exemple, veiem que la funció ‘printVal’ accepta un punter que no és const. A la funció principal, tenim una variable const 'valor' assignada al punter const ptr.

Per passar aquest punter de const a la funció printVal, el llancem aplicant per tal d’eliminar la constància. A continuació, passem el punter ptr_cast a la funció per obtenir els resultats desitjats.

Conclusió

Amb això, resumirem aquest tema de la conversió de tipus en C ++. Hem vist tot sobre conversions implícites i explícites que s’utilitzen a C ++.

Tanmateix, cal tenir en compte que, per evitar la pèrdua de dades i altres dificultats d’aquest tipus, les conversions o tipografies només s’han d’aplicar amb prudència si la situació requereix l’ús.

=> Mireu aquí la guia de formació per a principiants C ++.

Lectura recomanada

^