Hur man konverterar datatyper i C++
I C++ finns det två sätt att ändra datatyper:
Implicit typkonvertering
Enligt de fördefinierade reglerna av C++-kodkompilatorn är implicit typkonvertering den typkonvertering som utförs av kompilatorn automatiskt utan krav på någon extern trigger från användaren. Denna typ av konvertering sker vanligtvis i ett program när det finns mer än en datatyp, och datatypen för uttryck inte matchar datatypen för variabeln som är involverad i detta uttryck.
För att undvika dataförlust under konvertering, ändrar kompilatorn som standard den lågprecisa datatypen med datatypen med högre precision. Till exempel kommer det att konvertera ett heltal till ett flytande snarare än att ändra det flytande till ett heltal för att förhindra dataförlust. Detta kallas marknadsföring. Följande är prioritetsdiagrammet för de olika datatyperna.
Beställning för typkonvertering
Den korrekta ordningen för typkonvertering ges som:
bool -- > röding -- > kort int -- > int -- > osignerad int -- > lång -- > osignerad lång -- > lång lång -- > flyta -- > dubbelt -- > lång dubbel
Variabeln för lågprecisionstyp konverteras till datatypen med hög precision för att förhindra dataförlust.
Exempel 1
I det här exemplet utförs addition på variabeln för olika datatyper med hjälp av den implicita typkonverteringen.
#include
använder sig av namnutrymme std ;
int huvud ( ) {
int siffra = 100 ;
röding karaktär = 'C' ;
cout << '100 + 'C' = ' << siffra + karaktär << endl ;
flyta val = siffra + 'c' ;
cout << 'float val(100 + 'c') = ' << val << endl ;
int var = 7890 ;
lång var_int = var ;
cout << 'var_int = ' << var_int ;
lämna tillbaka 0 ;
}
Här läggs ett heltal och ett tecken från ASCII-tabellen och ett flytnummer och tecknet 'c' till. Heltalet hålls i det tredje segmentet som en lång datatyp och datatyperna ändras av kompilatorn själv baserat på dess fördefinierade regler.
Summan av 100 och 'C' returnerar 167 eftersom 'C' motsvarar 67 i siffror och 100+'c' returnerar 199 som gemener 'c' motsvarar 99. Int-variabeln lagras i en lång datatyp.
Exempel 2
I det här exemplet omvandlas tecknet D till en float för att utföra divisionsoperationen.
#includeanvänder sig av namnutrymme std ;
int huvud ( ) {
röding x = 'D' ;
flyta float_var ;
float_var = flyta ( x ) / 'c' ;
// Konverterar uttryckligen en int till en float.
cout << 'Värdet på float_var är: ' << float_var << endl ;
lämna tillbaka 0 ;
}
Inmatningsvärdet är i form av tecknet D som lagras i flytdatatyp och vidare dividerat med tecknet C. Dessa tecken ändras till numeriska värden och en divisionsoperation utförs på dem, vilket returnerar värdet i flytande.
Explicit typkonvertering
Användaren måste manuellt ändra datatypen med C++s explicita typkonvertering, ofta känd som typcasting. Denna typ av gjutning görs för att undvika den implicita typkonverteringen. Det finns två metoder för att utföra Explicit Type Casting i C++:
- Konvertering med Assignment Operator
- Konvertering med hjälp av Cast-operatören
Skriv Konvertering med Assignment Operator i C++
Typkonvertering med Assignment Operator görs kraftfullt, det vill säga en datatyp konverteras till en annan manuellt. Detta görs genom att använda tilldelningsoperatorn '=', som tilldelar värdet på den högra operanden till variabeln på dess vänstra sida.
Exempel
Detta program beräknar cirkelns area med hjälp av typgjutning.
#inkludera
använder sig av namnutrymme std ;
int huvud ( )
{
int radie ;
cout <> radie ;
flyta område = M_PI * radie * radie ;
cout << 'Cirkelområde med radie' << radie << ' = ' << område ;
}
Tilldelningsoperatorn används för att tilldela flytvärdet till området, som består av värdet på radien i heltalsdatatyp.
Cirkelns area returneras i flytdatatyp, medan radien matas in i heltalsdatatyp. Således ändras variabelns datatyp via typcasting med hjälp av tilldelningsoperatorn.
Typkonvertering med hjälp av Cast-operatören i C++
Typkonvertering görs med hjälp av en cast-operator, som tvingar en datatyp att ändras till en annan typ enligt programmets behov.
Det finns fyra olika Cast Operators:
- static_cast
- const_cast
- dynamic_cast
- reinterpret_cast
1: static_cast
Static_cast är cast-operatorn som används för att explicit konvertera flytningar och tecken till heltal och så vidare. Detta är den mest grundläggande rolloperatorn. Det kan casta datatyper som är liknande till sin natur. Den kan konvertera pekare från en form till en annan, så den kan också användas för minneshantering.
Syntax
static_cast ( uttryck ) Exempel
Detta program är byggt för att konvertera en dubbel variabel till en int-datatyp med static_cast. Det kommer att skära bort alla decimaldelar i utdata.
använder sig av namnutrymme std ;
int huvud ( )
{
// deklarera en variabel
dubbel sid ;
sid = 2 905 * 1 235 * 24,675 ;
flyta resultat ;
cout << ' Innan du använder det statiska gipset:' << endl ;
cout << ' Värdet av p = ' << sid << endl ;
// använd static_cast för att konvertera datatypen
resultat = static_cast ( sid ) ;
cout << ' Efter att ha använt den statiska rösten: ' << endl ;
cout << ' Värdet på resultatet = ' << resultat << endl ;
lämna tillbaka 0 ;
}
Inledningsvis laddas en dubbel variabel p med värden som multipliceras med varandra och lagras i resultatet. Resultatet innehåller resultatet före och efter static_cast-operatorn:
Innan du använder static_cast-operatorn visas resultatet med decimaler, medan efter användning av denna operator visas det i heltalsdatatyp.
2: const_cast
Operatören const_cast används för att konvertera ett konstant värde för ett objekt till den icke-konstanta typen. Det används där ett konstant objekt deklareras, och vi behöver ändra dess värde då och då.
Syntax
const_cast ( uttryck ) Exempel
I det här exemplet används const_cast-operatorn för att ta bort konstantkvalificeraren tillfälligt och gör det möjligt att göra ändringar i variabeln efter behov:
använder sig av namnutrymme std ;
int huvud ( ) {
konst int x = 70 ;
konst int * och = & x ;
cout << 'Gammalt värde är' << * och << ' \n ' ;
int * Med = const_cast ( och ) ;
* Med = 90 ;
cout << 'Nytt värde är' << * och ;
lämna tillbaka 0 ;
}
Konstantkvalificeraren är tilldelad en int-variabel x vilket innebär att denna variabel inte kan modifieras direkt. Efter det används int *y som är en pekare för att komma åt x, men det kan fortfarande inte ändras, och dess ursprungliga värde visas med cout. Med hjälp av operatorn const_cast skapas en pekare z som är icke-konstant, den används för att komma åt värdet på x vilket gör det redigerbart. Det ändrar värdet som tilldelas z med 90 vilket indirekt ändrar värdet i x.
Inledningsvis är värdet på konstant variabel x 70, vilket ändras genom att använda operatorn const_cast, vilket gör det till 90.
3: dynamic_cast
med arvshierarkin, som också benämns typsäker downcast. Nedgjutning är processen att konvertera en referens eller pekare till en härledd klass från en basklassreferens eller pekare.
Syntax
dynamic_cast ( uttryck ) Exempel
I det här exemplet används dynamic_cast-operatorn för att kontrollera typen av polymorf klass, och den tillåter åtkomst till både bas- och härledda klassmedlemmar.
#inkludera
använder sig av namnutrymme std ;
klass TBase
{
offentlig :
flyta bas_g = 9,81 ;
virtuell tomhet dummy ( )
{
} ;
} ;
klass THärledd : offentlig TBase
{
offentlig :
int lokal_g = 9,78 ;
} ;
int huvud ( )
{
TBase * bas = ny THärledd ;
THärledd * härledd ;
härledd = dynamic_cast ( bas ) ;
cout < bas_g << endl ;
cout < lokal_g << endl ;
getchar ( ) ;
lämna tillbaka 0 ;
}
Två klasser definieras som basklasser och härledda klasser. En pekarbas av typen TBase* skapas och tilldelas ett dynamiskt allokerat objekt av typen TDerived. Ett härlett klassobjekt kan tilldelas en basklasspekare i detta fall av polymorfism. Dynamic_cast kontrollerar om pekaren kommer åt det giltiga objektet i TDerived, om casten får ett framgångsrikt resultat kommer den härledda klassen att få ett giltigt resultat annars returnerar den ett nollvärde.
4: retolk_cast
Reinterpret_cast omvandlar en pekare av en datatyp till en pekare av en annan datatyp. Den kontrollerar inte om datatyperna för pekare är desamma eller inte. Denna gjutmaskin måste användas och hanteras varsamt.
Exempel
I den här illustrationen omtolkas pekaren för en datatyp till en pekare av en annan datatyp med hjälp av reinterpret_cast:
använder sig av namnutrymme std ;
int huvud ( )
{
int * q = ny int ( 70 ) ;
röding * kap = reinterpret_cast ( q ) ;
cout << * q << endl ;
cout << * kap << endl ;
cout << q << endl ;
cout << kap << endl ;
lämna tillbaka 0 ;
}
Inledningsvis tilldelas ett heltal värdet 70. Pekaren q pekar på detta dynamiskt allokerade heltal. Reinterpret_cast används för att omtolka pekaren q som en teckenpekare ch, vilket innebär att minnet som ursprungligen tilldelats q nu behandlas som om det vore ett tecken. Med hjälp av cout-kommandot skriver den ut värdet som tilldelats q och ch. Eftersom ch behandlas som en teckenpekare, returnerar den ett teckenvärde.
Den skriver ut värdet pekade på ch med *ch. Men eftersom ch behandlas som en teckenpekare kommer denna rad att tolka minnet som ett tecken. Den skriver ut minnesadressen som är lagrad i pekaren ch med ch. Detta är samma minnesadress som q eftersom det bara är en omtolkning av samma minne.
Initialt lagrar heltal 70. Senare manipuleras detta mellan pekaren q och pekaren ch. Utgångar 2 och 4 är desamma eftersom det andra värdet omtolkas med hjälp av reinterpret_cast.
Notera : Det rekommenderas att inte använda denna gjutningsoperator förrän och om det inte behövs mycket eftersom det gör objektet till en icke-bärbar produkt
Slutsats
Processen att ändra datatypen för en variabel till en annan kallas typkonvertering eller typgjutning i C++. Detta görs för att utföra matematiska operationer på variablerna för olika datatyper, genom att göra deras datatyper kompatibla med varandra. Typkonvertering optimerar koden. Det finns implicita och explicita typkonverteringar i C++. Implicit typkonvertering utförs av kompilatorn själv med hjälp av en fördefinierad uppsättning regler, medan explicit typkonvertering utförs av programmeraren med tilldelningsoperatorer och castoperatorer.