Sådan konverteres datatyper i C++
I C++ er der to måder at ændre datatyper på:
Implicit typekonvertering
I henhold til de foruddefinerede regler af C++-kodekompileren er implicit typekonvertering den typekonvertering, der udføres af compileren automatisk uden krav om nogen ekstern trigger fra brugeren. Denne type konvertering finder normalt sted i et program, når der er mere end én datatype, og datatypen for udtryk ikke matcher datatypen for den variabel, der er involveret i dette udtryk.
For at undgå datatab under konverteringen ændrer compileren som standard den lave præcise datatype med datatypen med højere præcision. For eksempel vil den konvertere et heltal til en float i stedet for at ændre float til et heltal for at forhindre tab af data. Dette kaldes forfremmelse. Følgende er præferencediagrammet for de forskellige datatyper.
Ordre til Typekonvertering
Den korrekte rækkefølge for typekonvertering er angivet som:
bool -- > char -- > kort int -- > int -- > usigneret int -- > lang -- > usigneret lang -- > lang lang -- > flyde -- > dobbelt -- > lang dobbelt
Variablen af lavpræcisionstype konverteres til datatypen med høj præcision for at forhindre tab af data.
Eksempel 1
I dette eksempel udføres addition på variablen af forskellige datatyper ved hjælp af den implicitte typekonvertering.
#include
ved brug af navneområde std ;
int vigtigste ( ) {
int nummer = 100 ;
char Karakter = 'C' ;
cout << '100 + 'C' = ' << nummer + Karakter << endl ;
flyde val = nummer + 'c' ;
cout << 'float val(100 + 'c') = ' << val << endl ;
int var = 7890 ;
lang var ikke = var ;
cout << 'var_int = ' << var ikke ;
Vend tilbage 0 ;
}
Her tilføjes et heltal og et tegn fra ASCII-tabellen, og et flydende tal og tegn 'c'. Heltallet holdes i det tredje segment som en lang datatype, og datatyperne ændres af compileren selv baseret på dens foruddefinerede regler.
Summen af 100 og 'C' returnerer 167, da 'C' svarer til 67 i tal, og 100+'c' returnerer 199, da lille 'c' svarer til 99. Int-variablen er lagret i en lang datatype.
Eksempel 2
I dette eksempel konverteres tegnet D til en flyder for at udføre divisionsoperationen.
#includeved brug af navneområde std ;
int vigtigste ( ) {
char x = 'D' ;
flyde float_var ;
float_var = flyde ( x ) / 'c' ;
// Eksplicit konvertering af en int til en float.
cout << 'Værdien af float_var er: ' << float_var << endl ;
Vend tilbage 0 ;
}
Indtastningsværdien er i form af tegnet D, som er lagret i flydende datatype og yderligere divideret med karakteren C. Disse tegn ændres til numeriske værdier, og der udføres en divisionsoperation på dem, hvilket returnerer værdien i float.
Eksplicit typekonvertering
Brugeren skal manuelt ændre datatypen med C++'s eksplicitte typekonvertering, ofte kendt som typecasting. Denne type støbning udføres for at undgå den implicitte typekonvertering. Der er to metoder til at udføre Explicit Type Casting i C++:
- Konvertering ved hjælp af Assignment Operator
- Konvertering ved hjælp af Cast Operator
Skriv Konvertering ved hjælp af Assignment Operator i C++
Typekonvertering ved hjælp af Assignment Operator udføres kraftigt, det vil sige, at en datatype konverteres til en anden manuelt. Dette opnås ved at bruge tildelingsoperatoren '=', som tildeler værdien af den højre operand til variablen på dens venstre side.
Eksempel
Dette program beregner arealet af cirklen ved hjælp af typestøbning.
#include
ved brug af navneområde std ;
int vigtigste ( )
{
int radius ;
cout <> radius ;
flyde areal = M_PI * radius * radius ;
cout << 'cirkelområde med radius' << radius << ' = ' << areal ;
}
Tildelingsoperatoren bruges til at tildele den flydende værdi til området, som består af værdien af radius i heltalsdatatypen.
Cirklens areal returneres i flydende datatype, mens radius indtastes i heltalsdatatype. Variablens datatype ændres således via typecasting ved hjælp af tildelingsoperatoren.
Typekonvertering ved hjælp af Cast-operatøren i C++
Typekonvertering udføres ved at bruge en cast-operator, som tvinger én datatype til at skifte til en anden type i henhold til programmets behov.
Der er fire forskellige medvirkende operatører:
- static_cast
- const_cast
- dynamisk_cast
- genfortolke_cast
1: static_cast
Static_cast er casting-operatoren, der bruges til eksplicit at konvertere flydere og tegn til heltal og så videre. Dette er den mest basale cast-operatør. Det kan caste datatyper, der ligner hinanden. Den kan konvertere pointere fra en form til en anden, så den kan også bruges til hukommelsesstyring.
Syntaks
static_cast ( udtryk ) Eksempel
Dette program er bygget til at konvertere en dobbelt variabel til en int datatype ved hjælp af static_cast. Det vil afskære enhver decimaldel i outputtet.
ved brug af navneområde std ;
int vigtigste ( )
{
// erklære en variabel
dobbelt s ;
s = 2.905 * 1.235 * 24.675 ;
flyde resultat ;
cout << 'Før du bruger den statiske cast:' << endl ;
cout << ' Værdien af p = ' << s << endl ;
// brug static_cast til at konvertere datatypen
resultat = static_cast ( s ) ;
cout << ' Efter brug af den statiske cast: ' << endl ;
cout << ' Værdien af resultatet = ' << resultat << endl ;
Vend tilbage 0 ;
}
Indledningsvis indlæses en dobbelt variabel p med værdier, der ganges med hinanden og lagres i resultatet. Resultatet indeholder resultatet før og efter static_cast-operatoren:
Før du bruger static_cast-operatoren, vises resultatet i decimaler, mens det efter brug af denne operator vises i heltalsdatatype.
2: const_cast
Const_cast-operatoren bruges til at konvertere en konstant værdi af et objekt til den ikke-konstante type. Det bruges, hvor et konstant objekt erklæres, og vi er nødt til at ændre dets værdi lejlighedsvis.
Syntaks
const_cast ( udtryk ) Eksempel
I dette eksempel bruges const_cast-operatoren til midlertidigt at fjerne konstant-kvalifikationen og tillader at foretage ændringer i variablen efter behov:
ved brug af navneområde std ;
int vigtigste ( ) {
konst int x = 70 ;
konst int * og = & x ;
cout << 'Gamle værdi er' << * og << ' \n ' ;
int * Med = const_cast ( og ) ;
* Med = 90 ;
cout << 'Ny værdi er' << * og ;
Vend tilbage 0 ;
}
Konstant-kvalifikationen er tildelt en int-variabel x, hvilket betyder, at denne variabel ikke kan ændres direkte. Derefter bruges int *y, som er en pointer, til at få adgang til x, men den kan stadig ikke ændres, og dens oprindelige værdi vises ved hjælp af cout. Ved at bruge const_cast-operatoren oprettes en pointer z, som er ikke-konstant, den bruges til at få adgang til værdien af x, hvilket gør den redigerbar. Det ændrer værdien tildelt z med 90, hvilket indirekte ændrer værdien i x.
Indledningsvis er værdien af konstant variabel x 70, som ændres ved at bruge const_cast-operatoren, hvilket gør den til 90.
3: dynamisk_cast
med arvehierarkiet, som også omtales som typesikkert nedkast. Nedstøbning er processen med at konvertere en reference eller pointer til en afledt klasse fra en basisklassereference eller pointer.
Syntaks
dynamisk_cast ( udtryk ) Eksempel
I dette eksempel bruges dynamic_cast-operatoren til at kontrollere typen af polymorf klasse, og den giver adgang til både basis- og afledte klassemedlemmer.
#inkluder
ved brug af navneområde std ;
klasse TBase
{
offentlig :
flyde base_g = 9,81 ;
virtuelle ugyldig dummy ( )
{
} ;
} ;
klasse TAfledt : offentlig TBase
{
offentlig :
int lokal_g = 9,78 ;
} ;
int vigtigste ( )
{
TBase * grundlag = ny TAfledt ;
TAfledt * afledt ;
afledt = dynamisk_cast ( grundlag ) ;
cout < base_g << endl ;
cout < lokal_g << endl ;
getchar ( ) ;
Vend tilbage 0 ;
}
To klasser er defineret som basisklasser og afledte klasser. En pointerbase af typen TBase* oprettes og tildeles til et dynamisk allokeret objekt af typen TDerived. Et afledt klasseobjekt kan tildeles en basisklassepointer i dette tilfælde af polymorfi. Dynamic_cast kontrollerer, om markøren får adgang til det gyldige objekt i TDerived, hvis castet får et vellykket resultat, vil den afledte klasse få et gyldigt resultat, ellers vil den returnere en nulværdi.
4: genfortolke_cast
Reinterpret_cast transformerer en pointer af én datatype til en pointer af en anden datatype. Den kontrollerer ikke, om datatyperne af pointere er de samme eller ej. Denne støbeoperatør skal bruges og håndteres forsigtigt.
Eksempel
I denne illustration genfortolkes markøren for én datatype til en markør af en anden datatype ved hjælp af reinterpret_cast:
ved brug af navneområde std ;
int vigtigste ( )
{
int * q = ny int ( 70 ) ;
char * ch = genfortolke_cast ( q ) ;
cout << * q << endl ;
cout << * ch << endl ;
cout << q << endl ;
cout << ch << endl ;
Vend tilbage 0 ;
}
Indledningsvis tildeles et heltal værdien 70. Markøren q peger på dette dynamisk allokerede heltal. Reinterpret_cast bruges til at genfortolke markøren q som en tegnmarkør ch, hvilket betyder, at den hukommelse, der oprindeligt er tildelt q, nu behandles som om den er et tegn. Ved at bruge cout-kommandoen udskrives den værdi, der er tildelt q og ch. Da ch behandles som en tegnmarkør, vil den returnere en tegnværdi.
Den udskriver værdien pegede på ch ved hjælp af *ch. Men da ch behandles som en tegnmarkør, vil denne linje fortolke hukommelsen som et tegn. Den udskriver hukommelsesadressen gemt i markøren ch ved hjælp af ch. Dette er den samme hukommelsesadresse som q, fordi det blot er en nyfortolkning af den samme hukommelse.
Indledningsvis lagrer heltal 70. Senere manipuleres dette mellem pointer q og pointer ch. Output 2 og 4 er de samme, fordi den anden værdi genfortolkes ved hjælp af reinterpret_cast.
Bemærk : Det anbefales ikke at bruge denne støbte operatør, før og medmindre der er meget behov for det, da det gør objektet til et ikke-bærbart produkt
Konklusion
Processen med at ændre datatypen for en variabel til en anden er kendt som typekonvertering eller typestøbning i C++. Dette gøres for at udføre matematiske operationer på variablerne af forskellige datatyper ved at gøre deres datatyper kompatible med hinanden. Typekonvertering optimerer koden. Der er implicitte og eksplicitte typekonverteringer i C++. Implicit typekonvertering udføres af compileren selv ved hjælp af et foruddefineret sæt regler, mens eksplicit typekonvertering udføres af programmøren ved hjælp af tildelingsoperatorer og cast-operatorer.