I dette emnet vil vi diskutere konvertering av en datatype til en annen i programmeringsspråket C++. Typekonvertering er prosessen som konverterer den forhåndsdefinerte datatypen til én variabel til en passende datatype. Hovedideen bak typekonvertering er å konvertere to forskjellige datatypevariabler til en enkelt datatype for å løse matematiske og logiske uttrykk enkelt uten tap av data.
For eksempel legger vi til to tall, der en variabel er av int-type og en annen av float-type; vi må konvertere eller typecaste int-variabelen til en float for å gjøre dem begge flytende datatyper for å legge dem til.
Typekonvertering kan gjøres på to måter i C++, den ene er implisitt typekonvertering , og den andre er eksplisitt typekonvertering . Disse konverteringene gjøres av kompilatoren selv, kalt implisitt type eller automatisk typekonvertering. Konverteringen, som gjøres av brukeren eller krever brukerinterferenser kalt den eksplisitte eller brukerdefinerte konverteringstypen. La oss diskutere den implisitte og eksplisitte typekonverteringen i C++.
Implisitt typekonvertering
Den implisitte typekonverteringen er den typen konvertering som gjøres automatisk av kompilatoren uten noen menneskelig innsats. Det betyr at en implisitt konvertering automatisk konverterer én datatype til en annen type basert på noen forhåndsdefinerte regler for C++-kompilatoren. Derfor er det også kjent som automatisk typekonvertering .
java og swing
For eksempel:
int x = 20; short int y = 5; int z = x + y;
I eksemplet ovenfor er det to forskjellige datatypevariabler, x og y, der x er en int-type, og y-en er av kort int-datatype. Og den resulterende variabelen z er også en heltallstype som lagrer x- og y-variabler. Men C++-kompilatoren konverterer automatisk den lavere rangerte datatypen (kort int)-verdi til høyere type (int) før den resulterer i summen av to tall. Dermed unngår den tap av data, overløp eller tegntap i implisitt typekonvertering av C++.
Rekkefølge av typecast i implisitt konvertering
Følgende er riktig rekkefølge av datatyper fra lavere rangering til høyere rangering:
bool -> char -> short int -> int -> unsigned int -> long int -> unsigned long int -> long long int -> float -> double -> long double
Program for å konvertere int til float type ved hjelp av implisitt type konvertering
La oss lage et program for å konvertere mindre rangerte datatyper til høyere typer ved hjelp av implisitt typekonvertering.
Program1.cpp
hvordan endre streng til int
#include using namespace std; int main () { // assign the integer value int num1 = 25; // declare a float variable float num2; // convert int value into float variable using implicit conversion num2 = num1; cout << ' The value of num1 is: ' << num1 << endl; cout << ' The value of num2 is: ' << num2 << endl; return 0; } Produksjon
The value of num1 is: 25 The value of num2 is: 25
Program for å konvertere dobbel til int-datatype ved hjelp av implisitt typekonvertering
La oss lage et program for å konvertere den høyere datatypen til lavere type ved hjelp av implisitt typekonvertering.
Program2.cpp
#include using namespace std; int main() { int num; // declare int type variable double num2 = 15.25; // declare and assign the double variable // use implicit type conversion to assign a double value to int variable num = num2; cout << ' The value of the int variable is: ' << num << endl; cout << ' The value of the double variable is: ' << num2 << endl; return 0; } Produksjon
The value of the int variable is: 15 The value of the double variable is: 15.25
I programmet ovenfor har vi erklært num som en heltallstype og num2 som den doble datatypevariabelen og deretter tildelt num2 som 15.25. Etter dette tildeler vi num2-verdien til num-variabelen ved å bruke tilordningsoperatoren. Så en C++-kompilator konverterer automatisk den doble dataverdien til heltallstypen før den tilordner den til num-variabelen og skriver ut avkortingsverdien som 15.
Eksplisitt typekonvertering
Konverteringer som krever brukerinngrep å endre datatypen til en variabel til en annen, kalles eksplisitt typekonvertering . Med andre ord, en eksplisitt konvertering lar programmereren manuelt endre eller typecaste datatypen fra en variabel til en annen type. Derfor er det også kjent som typecasting. Generelt tvinger vi den eksplisitte typekonverteringen til å konvertere data fra én type til en annen fordi den ikke følger den implisitte konverteringsregelen.
Den eksplisitte typekonverteringen er delt inn på to måter:
- Eksplisitt konvertering ved hjelp av rollebesetningsoperatøren
- Eksplisitt konvertering ved hjelp av oppdragsoperatøren
Program for å konvertere float-verdi til int-type ved hjelp av cast-operatøren
Cast-operatør: I C++-språket er en cast-operatør en unær operatør som med kraft konverterer en type til en annen type.
lagre youtube video vlc
La oss vurdere et eksempel for å konvertere float-datatypen til int-type ved å bruke cast-operatoren for den eksplisitte konverteringen i C++-språket.
Program3.cpp
#include using namespace std; int main () { float f2 = 6.7; // use cast operator to convert data from one type to another int x = static_cast (f2); cout << ' The value of x is: ' << x; return 0; } Produksjon
The value of x is: 6
Program for å konvertere en datatype til en annen ved å bruke tilordningsoperatøren
La oss vurdere et eksempel for å konvertere datatypen til en variabel til en annen ved å bruke tilordningsoperatøren i C++-programmet.
Program4.cpp
#include using namespace std; int main () { // declare a float variable float num2; // initialize an int variable int num1 = 25; // convert data type from int to float num2 = (float) num1; cout << ' The value of int num1 is: ' << num1 << endl; cout << ' The value of float num2 is: ' << num2 << endl; return 0; } Produksjon
The value of int num1 is: 25 The value of float num2 is: 25.0