Hvordan konvertere datatyper i C++
I C++ er det to måter å endre datatyper på:
Implisitt typekonvertering
I henhold til de forhåndsdefinerte reglene av C++-kodekompilatoren, er implisitt typekonvertering typekonverteringen som utføres av kompilatoren automatisk uten krav om noen ekstern trigger fra brukeren. Denne typen konvertering finner vanligvis sted i et program når det er mer enn én datatype, og datatypen uttrykk ikke samsvarer med datatypen til variabelen som er involvert i dette uttrykket.
For å unngå tap av data under konvertering, endrer kompilatoren som standard den lave presise datatypen med datatypen med høyere presisjon. For eksempel vil den konvertere et heltall til en flytende i stedet for å endre flyten til et heltall for å forhindre tap av data. Dette kalles promotering. Følgende er prioritetsdiagrammet for de forskjellige datatypene.
Ordre for typekonvertering
Riktig rekkefølge for typekonvertering er gitt som:
bool -- > røye -- > kort int -- > int -- > usignert int -- > lang -- > usignert lang -- > lang lang -- > flyte -- > dobbel -- > lang dobbel
Variabelen for lavpresisjonstype konverteres til datatypen med høy presisjon for å forhindre tap av data.
Eksempel 1
I dette eksemplet utføres addisjon på variabelen til forskjellige datatyper ved å bruke den implisitte typekonverteringen.
#include
ved hjelp av navneområde std ;
int hoved- ( ) {
int Antall = 100 ;
røye karakter = 'C' ;
cout << '100 + 'C' = ' << Antall + karakter << endl ;
flyte val = Antall + 'c' ;
cout << 'float val(100 + 'c') = ' << val << endl ;
int var = 7890 ;
lang var ikke = var ;
cout << 'var_int = ' << var ikke ;
komme tilbake 0 ;
}
Her legges et heltall og et tegn fra ASCII-tabellen, og et flyttall og tegnet 'c' til. Heltallet holdes i det tredje segmentet som en lang datatype, og datatypene endres av kompilatoren selv basert på forhåndsdefinerte regler.
Summen av 100 og 'C' returnerer 167 som 'C' tilsvarer 67 i tall og 100+'c' returnerer 199 som liten 'c' tilsvarer 99. Int-variabelen er lagret i en lang datatype.
Eksempel 2
I dette eksemplet konverteres tegnet D til en flyte for å utføre divisjonsoperasjonen.
#includeved hjelp av navneområde std ;
int hoved- ( ) {
røye x = 'D' ;
flyte float_var ;
float_var = flyte ( x ) / 'c' ;
// Eksplisitt konvertere en int til en float.
cout << 'Verdien av float_var er: ' << float_var << endl ;
komme tilbake 0 ;
}
Inndataverdien er i form av tegnet D som lagres i flytende datatype og videre divideres med tegnet C. Disse tegnene endres til numeriske verdier og det utføres en divisjonsoperasjon på dem, som returnerer verdien i flytende.
Eksplisitt typekonvertering
Brukeren må manuelt endre datatypen med C++s eksplisitte typekonvertering, ofte kjent som typecasting. Denne typen støping gjøres for å unngå den implisitte typekonverteringen. Det er to metoder for å utføre Explicit Type Casting i C++:
- Konvertering ved hjelp av oppdragsoperatøren
- Konvertering ved hjelp av Cast-operatøren
Skriv Konvertering ved å bruke Assignment Operator i C++
Typekonvertering ved hjelp av Assignment Operator gjøres kraftig, det vil si at én datatype konverteres til en annen manuelt. Dette oppnås ved å bruke tilordningsoperatoren '=', som tildeler verdien av høyreoperanden til variabelen på venstre side.
Eksempel
Dette programmet beregner arealet av sirkelen ved hjelp av typestøping.
#include
ved hjelp av navneområde std ;
int hoved- ( )
{
int radius ;
cout <> radius ;
flyte område = M_PI * radius * radius ;
cout << 'Sirkelområde med radius' << radius << ' = ' << område ;
}
Tilordningsoperatoren brukes til å tilordne flyteverdien til området, som består av verdien av radius i heltallsdatatype.
Arealet av sirkelen returneres i flytende datatype, mens radiusen legges inn i heltallsdatatype. Dermed endres variabelens datatype via typecasting ved hjelp av tilordningsoperatøren.
Typekonvertering ved å bruke Cast-operatøren i C++
Typekonvertering gjøres ved å bruke en cast-operatør, som tvinger en datatype til å endre til en annen type i henhold til programmets behov.
Det er fire forskjellige rollebesetningsoperatører:
- static_cast
- const_cast
- dynamic_cast
- reinterpret_cast
1: static_cast
Static_cast er casting-operatoren som brukes til å eksplisitt konvertere flyter og tegn til heltall og så videre. Dette er den mest grunnleggende cast-operatøren. Den kan caste datatyper som er av lignende natur. Den kan konvertere pekere fra en form til en annen, så den kan også brukes til minnebehandling.
Syntaks
static_cast ( uttrykk ) Eksempel
Dette programmet er bygget for å konvertere en dobbel variabel til en int-datatype ved å bruke static_cast. Den vil kutte av enhver desimaldel i utdataene.
ved hjelp av navneområde std ;
int hoved- ( )
{
// erklære en variabel
dobbelt s ;
s = 2.905 * 1235 * 24.675 ;
flyte resultat ;
cout << 'Før du bruker den statiske støpen:' << endl ;
cout << ' Verdien av p = ' << s << endl ;
// bruk static_cast for å konvertere datatypen
resultat = static_cast ( s ) ;
cout << ' Etter å ha brukt den statiske casten: ' << endl ;
cout << 'Verdien av resultatet = ' << resultat << endl ;
komme tilbake 0 ;
}
Til å begynne med lastes en dobbel variabel p med verdier som multipliseres med hverandre og lagres i resultatet. Resultatet inneholder resultatet før og etter static_cast-operatoren:
Før du bruker static_cast-operatoren, vises resultatet i desimaltegn, mens etter bruk av denne operatoren vises det i heltallsdatatype.
2: const_cast
Const_cast-operatoren brukes til å konvertere en konstant verdi av et objekt til den ikke-konstante typen. Den brukes der et konstant objekt er deklarert, og vi må endre verdien av og til.
Syntaks
const_cast ( uttrykk ) Eksempel
I dette eksemplet brukes const_cast-operatoren til å fjerne konstantkvalifiseringen midlertidig og tillater å gjøre endringer i variabelen i henhold til behovet:
ved hjelp av navneområde std ;
int hoved- ( ) {
konst int x = 70 ;
konst int * og = & x ;
cout << 'Gammel verdi er' << * og << ' \n ' ;
int * Med = const_cast ( og ) ;
* Med = 90 ;
cout << 'Ny verdi er' << * og ;
komme tilbake 0 ;
}
Konstantkvalifikatoren er tilordnet en int-variabel x som betyr at denne variabelen ikke kan endres direkte. Etter det brukes int *y som er en peker for å få tilgang til x, men den kan fortsatt ikke endres, og dens opprinnelige verdi vises ved hjelp av cout. Ved å bruke const_cast-operatoren opprettes en peker z som er ikke-konstant, den brukes for å få tilgang til verdien av x som gjør den redigerbar. Den endrer verdien tildelt z med 90 som indirekte endrer verdien i x.
Innledningsvis er verdien av konstant variabel x 70 som endres ved å bruke const_cast-operatoren, noe som gjør den til 90.
3: dynamic_cast
med arvehierarkiet, som også omtales som typesikker nedkast. Nedstøping er prosessen med å konvertere en referanse eller peker til en avledet klasse fra en basisklassereferanse eller peker.
Syntaks
dynamic_cast ( uttrykk ) Eksempel
I dette eksemplet brukes dynamic_cast-operatoren til å sjekke typen polymorf klasse, og den gir tilgang til både basis- og avledede klassemedlemmer.
#inkluder
ved hjelp av navneområde std ;
klasse TBase
{
offentlig :
flyte base_g = 9,81 ;
virtuell tomrom dummy ( )
{
} ;
} ;
klasse TDelt : offentlig TBase
{
offentlig :
int lokal_g = 9,78 ;
} ;
int hoved- ( )
{
TBase * utgangspunkt = ny TDelt ;
TDelt * avledet ;
avledet = dynamic_cast ( utgangspunkt ) ;
cout < base_g << endl ;
cout < lokal_g << endl ;
getchar ( ) ;
komme tilbake 0 ;
}
To klasser er definert som basisklasser og avledede klasser. En pekerbase av typen TBase* opprettes og tilordnes til et dynamisk allokert objekt av typen TDerived. Et avledet klasseobjekt kan tilordnes en basisklassepeker i dette tilfellet av polymorfisme. Dynamic_cast sjekker om pekeren får tilgang til det gyldige objektet til TDerived, hvis casten får et vellykket resultat vil den avledede klassen få et gyldig resultat ellers vil den returnere en nullverdi.
4: retolk_cast
Reinterpret_cast transformerer en peker av én datatype til en peker av en annen datatype. Den sjekker ikke om datatypene for pekere er de samme eller ikke. Denne støpeoperatøren må brukes og håndteres forsiktig.
Eksempel
I denne illustrasjonen blir pekeren til én datatype omtolket til en peker av en annen datatype ved hjelp av reinterpret_cast:
ved hjelp av navneområde std ;
int hoved- ( )
{
int * q = ny int ( 70 ) ;
røye * kap = reinterpret_cast ( q ) ;
cout << * q << endl ;
cout << * kap << endl ;
cout << q << endl ;
cout << kap << endl ;
komme tilbake 0 ;
}
Til å begynne med tildeles et heltall verdien 70. Pekeren q peker på dette dynamisk tildelte heltall. Reinterpret_cast brukes til å omtolke pekeren q som en tegnpeker ch, noe som betyr at minnet som opprinnelig ble tildelt q nå behandles som om det er et tegn. Ved å bruke cout-kommandoen skriver den ut verdien som er tildelt q og ch. Siden ch behandles som en tegnpeker, vil den returnere en tegnverdi.
Den skriver ut verdien pekt på ch ved hjelp av *ch. Men siden ch behandles som en tegnpeker, vil denne linjen tolke minnet som et tegn. Den skriver ut minneadressen som er lagret i pekeren ch ved hjelp av ch. Dette er den samme minneadressen som q fordi det bare er en nytolkning av det samme minnet.
Til å begynne med lagrer heltallet 70. Senere manipuleres dette mellom pekeren q og pekeren ch. Utganger 2 og 4 er de samme fordi den andre verdien tolkes på nytt ved å bruke reinterpret_cast.
Merk : Det anbefales å ikke bruke denne støpeoperatoren før og med mindre det er mye nødvendig, da det gjør objektet til et ikke-bærbart produkt
Konklusjon
Prosessen med å endre datatypen til en variabel til en annen er kjent som typekonvertering eller typecasting i C++. Dette gjøres for å utføre matematiske operasjoner på variablene til forskjellige datatyper, ved å gjøre datatypene deres kompatible med hverandre. Typekonvertering optimerer koden. Det er implisitte og eksplisitte typekonverteringer i C++. Implisitt typekonvertering utføres av kompilatoren selv ved å bruke et forhåndsdefinert sett med regler, mens eksplisitt typekonvertering utføres av programmereren ved å bruke tilordningsoperatører og cast-operatører.