Meny

Skriv konverteringer i C ++

type conversions c

Prøv Instrumentet Vårt For Å Eliminere Problemer

Sjekk ut de forskjellige typekonverteringene som støttes i C ++.

Vi håper du bør være oppmerksom på alle datatypene som er tilgjengelige i C ++ fra våre tidligere veiledninger. Noen ganger kan det oppstå et behov slik at vi trenger å konvertere en type til en annen. Dette kalles type konvertering eller type casting.

I denne opplæringen vil vi diskutere de forskjellige typekonverteringene som støttes i C ++.

datadrevet rammeverk i selen webdriver

=> Klikk her for gratis C ++ kurs.

Skriv konverteringer i C ++

Hva du vil lære:

Skriv konverteringer

C ++ støtter to typer type konverteringer:

  • Implisitt type konvertering: Implisitt type konvertering er automatisk. Det er ingen forstyrrelser fra brukeren i denne typen konvertering, og kompilatoren utfører konverteringen direkte. Konvertering gjøres vanligvis når det i uttrykk er mer enn en type data. Men generelt, i denne typen konvertering, er det en mulighet for tap av data, tap av tegn eller overløp av data.
  • Eksplisitt type konvertering: Eksplisitt type konvertering er brukerdefinert og kalles vanligvis “type casting”. Her kaster brukeren eller konverterer en verdi av en datatype til en annen, avhengig av kravene. Denne typen konverteringer er tryggere.

Nå vil vi se begge typer typekonvertering i detalj.

Implisitt konvertering

I implisitt konvertering utfører kompilatoren konverteringene fra en datatype til en annen når et uttrykk har mer enn en datatype. For å forhindre tap av data blir alle variablene til de andre datatypene konvertert til den største datatypen. Dette kalles forfremmelse.

La oss forstå Implisitt konvertering ved hjelp av et kodeeksempel.

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

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

var_int = 1000

Ovennevnte kodeeksempel viser implisitt konvertering. Vi har erklært et heltall og en tegnvariabel med henholdsvis verdiene 10 og ‘A’. Når vi legger sammen disse to variablene, skjer en implisitt konvertering.

Ettersom heltall er den større typen i dette uttrykket, konverteres tegnvariabelen verdien 'A' til dets heltall ekvivalent, dvs. verdi 65 (ASCII-verdi). Dermed er resultatet av uttrykket 75.

I neste uttrykk legger vi til heltall og karakter (‘a’ -> 97) og tilordner deretter resultatet til å flyte. Dermed blir resultatet av uttrykket implisitt konvertert til å flyte av kompilatoren.

I det tredje uttrykket konverteres en kort int-variabel implisitt til heltall.

Merk : I tilfelle implisitte konverteringer, hvis kompilatoren oppdager et potensielt tap av data, kan det blinke en advarsel om dette.

Eksplisitt konvertering

Eksplisitt konvertering er også kjent som 'type-casting' når vi 'cast' en datatype til en annen datatype. Her definerer brukerne eksplisitt castingen, i motsetning til implisitt konvertering der kompilatoren internt utfører konverteringen.

Vi kan utføre eksplisitt konvertering på to måter:

# 1) Bruke tildelingsoperatør

Eksplisitt konvertering eller typecasting ved hjelp av oppdragsoperatøren på en måte utføres kraftig. Her kaster eller konverterer vi en datatype til en annen datatype ved å bruke oppdragsoperatøren.

Den generelle syntaksen er:

(data type) expression;

Følgende eksempel forklarer dette:

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

I denne typen avstøpning bruker vi en 'cast operator' som er en unary operator for å bytte fra en type til en annen.

Typer avstøpning

Vi har følgende typer avstøpning, avhengig av rolleoperatøren vi bruker:

# 1) Statisk rollebesetning

Den statiske rollebesetningen er den enkleste blant alle typecasting som bruker cast-operatøren . Den statiske rollebesetningen er i stand til å utføre alle konverteringene som utføres implisitt. Den utfører også konverteringer mellom pekere av klasser relatert til hverandre (upcast -> fra avledet til base eller downcast -> fra base til avledet).

Bortsett fra de ovennevnte konverteringene, kan den statiske rollebesetningen også konvertere en hvilken som helst peker til ugyldig *.

Den statiske rollebesetningen er den kompilerte tiden. Dette betyr at det ikke er gjort noen sjekk ved kjøretid for å se om rollebesetningen er utført er gyldig eller ikke. Derfor forblir det programmørens ansvar å sikre at konverteringen var trygg og gyldig.

Med andre ord, brukeren må sørge for at det konverterte objektet var fullt med hensyn til destinasjonsdatatypen.

Vi spesifiserer en statisk rollebesetting som følger:

static_cast (expression)

La oss forstå statisk rollebesetning ved hjelp av et eksempel.

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

I eksemplet ovenfor har vi endret koden litt for å inkludere en tegnvariabel med verdien ‘A’. Deretter erklærer vi en heltallspeker og bruker en statisk rollebesetning for å konvertere et tegn til et heltallpeker.

Når vi kompilerer dette programmet får vi følgende utdata.

I funksjon ‘int main ()’:
10:35: feil: ugyldig static_cast fra type 'char *' til type 'int *'

Programmet gir en feil for den statiske rollebesetningen som er utført siden den er ugyldig. Dermed tillater statisk cast bare gyldig type casting eller konverteringer og gir en feil når vi prøver å utføre noen uønsket typecasting.

# 2) Dynamisk rollebesetning

Dynamisk rollebesetning er en runtime rollebesetning utført for å kontrollere gyldigheten av rollebesetningen. Dynamisk rollebesetning utføres bare på klassepekere og referanser. Uttrykket returnerer en NULL-verdi hvis rollebesetningen mislykkes.

Den dynamiske rollebesetningen bruker en mekanisme kjent som RTTI (Runtime Type Identification) . RTTI gjør all informasjon om objektets datatype tilgjengelig ved kjøretid og er kun tilgjengelig for klassene som har minst en virtuell funksjon (polymorf type). RTTI tillater å bestemme objekttypen ved kjøretid eller på tidspunktet for utførelse.

La oss prøve et eksempel for å forstå dynamisk rollebesetning.

#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 dette programmet har vi definert to klasser, base med en virtuell funksjon og avledet med en basisklasse, base.

I hovedfunksjonen lager vi et avledet klasseobjekt pekt på av baseklassepekeren. Deretter utfører vi dynamic_cast på basispekeren som peker på en avledet klasse for å kaste den til en avledet klassepeker.

Som i basisklassen er basen polymorf (inneholder virtuell funksjon), dynamisk-sendingen er vellykket.

Merk: Hvis vi fjerner den virtuelle funksjonen fra ovennevnte klasse, mislykkes dynamic_cast ettersom RTTI-informasjon for objektene ikke vil være tilgjengelig.

Den dynamiske rollebesetningen har en overhead av typesikkerhet ved kjøretid.

# 3) Gjennomfortolke rollebesetningen

Denne typen rollebesetninger er farligst å bruke, da den fungerer på alle typer objekter uten at klassene er relatert til hverandre.

Reintepret_cast fungerer på alle pekere, og den konverterer en peker av hvilken som helst type til en hvilken som helst annen type, uavhengig av om pekerne er relatert til hverandre eller ikke. Den sjekker ikke om pekeren eller dataene som pekeren peker på, er like eller ikke.

Cast-operatøren tar bare én parameter, kildepekeren som skal konverteres til og returnerer ingen verdi. Den konverterer ganske enkelt pekertypen.

Vi bør ikke bruke med mindre det er nødvendig. Vi skriver vanligvis kildepekeren til den opprinnelige typen.

Vi bruker mest for å jobbe med biter. Når det brukes på boolske verdier, konverteres boolske verdier til heltall, dvs. 1 for true og 0 for false.

La oss se et eksempel på omfortolkning av rollebesetningen:

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

Produksjon:

0x3ef3090
til
97
til

I eksemplet ovenfor har vi erklært et heltall peker ptr som peker til verdi 97. Deretter erklærer vi en tegnpeker ch og kaster ptr til den ved hjelp av.

Deretter skriver vi ut forskjellige verdier. Den første vi skriver ut er ptr som peker til et heltall. Derfor skriver den ut en adresse.

Den neste verdien ch inneholder verdien 97, og dermed skriver den ut 'a' som er ASCII-ekvivalent til 97. Den neste verdien '* ptr' holder verdien 97 mens '* ch' holder ASCII-ekvivalenten til 97 dvs. 'a' som den kastes ved hjelp av omtalingen.

# 4) Const Cast

Cast-operatøren brukes til å endre eller manipulere konstansen til kildepekeren. Med manipulasjon mener vi at det enten kan være å sette konstanse til en ikke-const-peker eller fjerne constness fra en const-peker.

Forutsetningen for å kunne støpe operatøren er at pekeren og kilden som støpes, skal være av samme type.

La oss ta et eksempel for å forstå dette.

hva er forskjellen mellom testplan og teststrategi
#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 dette eksemplet ser vi at funksjonen ‘printVal’ aksepterer en ikke-const-peker. I hovedfunksjonen har vi en const-variabel ‘verdi’ tildelt const-pekeren ptr.

For å overføre denne const-pekeren til funksjonen printVal, kaster vi den ved å bruke for å fjerne konstansen. Deretter sender vi pekeren ptr_cast til funksjonen for å få de ønskede resultatene.

Konklusjon

Med dette vil vi pakke inn dette emnet for typekonvertering i C ++. Vi har sett alt om implisitte og eksplisitte konverteringer som brukes i C ++.

Imidlertid bør man være oppmerksom på at for å forhindre tap av data og andre slike vanskeligheter, bør konvertering eller typecasting kun brukes klokt hvis situasjonen nødvendiggjør bruken.

=> Se opp nybegynnere C ++ treningsguide her.

Anbefalt lesing

^