Meny

Skriv omvandlingar i C ++

type conversions c

Prova Vårt Instrument För Att Eliminera Problem

Kolla in de olika typkonverteringar som stöds i C ++.

Vi hoppas att du bör vara medveten om alla datatyper som finns tillgängliga i C ++ från våra tidigare handledning. Ibland kan ett behov uppstå så att vi behöver konvertera en typ till en annan. Detta kallas typkonvertering eller typgjutning.

I denna handledning kommer vi att diskutera de olika typkonverteringar som stöds i C ++.

datadrivet ramverk i selen webdriver

=> Klicka här för gratis C ++ kurs.

Skriv omvandlingar i C ++

Vad du kommer att lära dig:

Skriv omvandlingar

C ++ stöder två typer av typkonverteringar:

  • Implicit typkonvertering: Implicit typkonvertering sker automatiskt. Det finns ingen störning från användaren i denna typ av konvertering och kompilatorn utför direkt konverteringen. Konvertering görs vanligtvis när det finns mer än en typ av data i uttrycket. Men i allmänhet finns det i denna typ av konvertering en möjlighet för dataförlust, förlust av tecken eller överflöd av data.
  • Explicit typkonvertering: Explicit typkonvertering är användardefinierad och kallas normalt ”typgjutning”. Här kastar eller konverterar användaren ett värde av en datatyp till en annan beroende på kraven. Den här typen av omvandlingar är säkrare.

Nu kommer vi att se båda typerna av typkonvertering i detalj.

Implicit konvertering

I implicit konvertering utför kompilatorn konverteringarna från en datatyp till en annan när ett uttryck har mer än en datatyp. För att förhindra förlust av data konverteras alla variabler för de andra datatyperna till den största datatypen. Detta kallas marknadsföring.

Låt oss förstå Implicit omvandling med hjälp av ett kodexempel.

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

flottörval (10 + ‘a’) = 107

var_int = 1000

Ovanstående kodexempel visar implicit konvertering. Vi har förklarat ett heltal och en teckenvariabel med värdena 10 respektive 'A'. När vi summerar dessa två variabler sker en implicit omvandling.

Eftersom heltal är den större typen i detta uttryck omvandlas teckenvariabelvärdet 'A' till dess heltalekvivalent, dvs. värde 65 (ASCII-värde). Således är resultatet av uttrycket 75.

I nästa uttryck lägger vi till heltal och tecken (‘a’ -> 97) och tilldelar sedan resultatet att flyta. Således omvandlas resultatet av uttrycket implicit till att flyta av kompilatorn.

I det tredje uttrycket omvandlas en kort int-variabel implicit till heltal.

Notera : Om kompilatorn upptäcker en potentiell förlust av data vid implicita konverteringar, kan den blinka en varning om detta.

Explicit omvandling

Explicit omvandling kallas också ”typgjutning” eftersom vi ”kastar” en datatyp till en annan datatyp. Här definierar användarna uttryckligen castingen, till skillnad från implicit konvertering där kompilatorn internt utför konverteringen.

Vi kan utföra Explicit Conversion på två sätt:

# 1) Använda Assignment Operator

Explicit konvertering eller typecasting med hjälp av tilldelningsoperatören på ett sätt utförs kraftfullt. Här kastar eller konverterar vi en datatyp till en annan datatyp med hjälp av tilldelningsoperatören.

Den allmänna syntaxen är:

(data type) expression;

Följande exempel förklarar detta:

#include #include using namespace std; int main() { int sum; double salary = 4563.75; sum = (int)salary + 1000; cout<<'Sum = '<# 2) Använda Cast Operator

I den här typen av gjutning använder vi en ”gjutoperatör” som är en enhetlig operatör för att byta från en typ till en annan.

Typer av gjutning

Vi har följande typer av gjutning beroende på vilken gjutoperatör vi använder:

# 1) Statisk gjutning

Den statiska casten är den enklaste bland alla typprognoser med cast-operatören . Den statiska rollgruppen kan utföra alla konverteringar som utförs implicit. Det utför också konverteringar mellan pekare i klasser relaterade till varandra (upcast -> från härledd till bas eller nedkastad -> från bas till härledd).

skillnad mellan b-träd och b-träd

Bortsett från ovanstående konverteringar kan den statiska rollen också konvertera vilken pekare som helst till ogiltig *.

Den statiska rollen är den sammanställda tidsbesättningen. Det betyder att det inte görs någon kontroll vid körning för att se om den gjutna rollen är giltig eller inte. Därför förblir det programmerarens ansvar att se till att konverteringen var säker och giltig.

Med andra ord måste användaren se till att det konverterade objektet var fullt med avseende på destinationsdatatypen.

Vi anger en statisk gjutning enligt följande:

static_cast (expression)

Låt oss förstå statisk cast med hjälp av ett exempel.

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

I exemplet ovan har vi modifierat koden något för att inkludera en teckenvariabel med värdet 'A'. Sedan deklarerar vi en helpekare och tillämpar en statisk roll för att konvertera ett tecken till en helpekare.

När vi sammanställer detta program får vi följande resultat.

I funktion 'int main ()':
10:35: fel: ogiltig static_cast från typ 'char *' till typ 'int *'

Programmet ger ett fel för den statiska rollen som utförs eftersom den är ogiltig. Således tillåter statisk gjutning endast giltig typgjutning eller konverteringar och ger ett fel när vi försöker utföra någon oönskad typgjutning.

# 2) Dynamic Cast

Dynamisk rollbesättning är en körning som körs för att kontrollera giltighetens roll. Dynamisk rollbesättning utförs endast på klasspekare och referenser. Uttrycket returnerar ett NULL-värde om rollen misslyckas.

Den dynamiska rollgruppen använder en mekanism som kallas RTTI (Runtime Type Identification) . RTTI gör all information om objektets datatyp tillgänglig under körning och är endast tillgänglig för de klasser som har minst en virtuell funktion (polymorf typ). RTTI gör det möjligt att bestämma objekttypen vid körning eller vid körningstillfället.

Låt oss prova ett exempel för att förstå Dynamic cast.

#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'; }

I det här programmet har vi definierat två klasser, bas med en virtuell funktion och härledd med basklass, bas.

I huvudfunktionen skapar vi ett härledt klassobjekt som basklasspekaren pekar på. Sedan utför vi dynamic_cast på baspekaren som pekar på en härledd klass för att kasta den till en härledd klasspekare.

Som i basklassen är basen polymorf (innehåller virtuell funktion), den dynamiska sändningen är framgångsrik.

Notera: Om vi ​​tar bort den virtuella funktionen från ovanstående klass misslyckas dynamic_cast eftersom RTTI-information för objekten inte kommer att finnas tillgänglig.

Den dynamiska rollen har en typ av säkerhet vid körning.

# 3) Omtolkar Cast

Denna typ av gjutning är farligast att använda eftersom den fungerar på alla typer av objekt utan att klasserna är relaterade till varandra.

Reintepret_cast fungerar på alla pekare och den konverterar en pekare av vilken typ som helst till vilken annan typ som helst, oavsett om pekarna är relaterade till varandra eller inte. Den kontrollerar inte om pekaren eller data som pekaren pekar på är samma eller inte.

Castoperatören tar bara en parameter, källpekaren att konvertera till och returnerar inget värde. Det konverterar helt enkelt pekartypen.

Vi ska inte använda om det inte krävs. Vi skriver vanligtvis källpekaren till sin ursprungliga typ.

Vi använder mest för att arbeta med bitar. När det används på booleska värden konverteras booleska värden till helvärden, dvs. 1 för true och 0 för false.

Låt oss se ett exempel på Reinterpret cast:

#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; }

Produktion:

0x3ef3090
till
97
till

I exemplet ovan har vi förklarat en helpekare ptr som pekar på värdet 97. Därefter deklarerar vi en teckenpekare ch och kastar ptr till den med hjälp av.

Därefter skriver vi ut olika värden. Det första vi skriver ut är ptr som pekar på ett heltal. Därför skriver den ut en adress.

Nästa värde ch innehåller värdet 97 och därmed skriver det ut 'a' som är ASCII-ekvivalent till 97. Nästa värde '* ptr' håller värdet 97 medan '* ch' håller ASCII-ekvivalenten 97 dvs 'a' när det gjuts med reinterpret_cast.

# 4) Const Cast

Cast-operatören används för att ändra eller manipulera konstruktion hos källpekaren. Med manipulation menar vi att det antingen kan vara att ställa konstruktion till en icke-konstpekare eller ta bort konsthet från en konstpekare.

Villkoret för att framgångsrikt casta operatören är att pekaren och källan som gjuts ska vara av samma typ.

Låt oss ta ett exempel för att förstå detta.

#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; }

I det här exemplet ser vi att funktionen 'printVal' accepterar en non-const-pekare. I huvudfunktionen har vi en const-variabel 'värde' tilldelad const-pekaren ptr.

För att skicka denna konstpekare till funktionen printVal, kastar vi den genom att applicera för att ta bort konstansen. Sedan skickar vi pekaren ptr_cast till funktionen för att få önskat resultat.

Slutsats

Med detta kommer vi att avsluta detta ämne av typkonvertering i C ++. Vi har sett allt om implicita och uttryckliga omvandlingar som används i C ++.

hur man lägger till svn-plugin i förmörkelse

Man bör dock vara medveten om att för att förhindra förlust av data och andra sådana svårigheter, bör konverteringar eller typprognoser tillämpas klokt endast om situationen kräver användning.

=> Se upp för nybörjare C ++ träningsguide här.

Rekommenderad läsning

^