Det här avsnittet kommer att diskutera typen av casting av variablerna i programmeringsspråket C++. Typgjutning avser konvertering av en datatyp till en annan i ett program. Typecasting kan göras på två sätt: automatiskt av kompilatorn och manuellt av programmeraren eller användaren. Typgjutning är också känd som typomvandling.
Anta till exempel att den givna datan är en heltalstyp och att vi vill konvertera den till flyttyp. Så vi måste gjuta int-data manuellt till float-typen, och den här typen av gjutning kallas Type Casting i C++.
int num = 5; float x; x = float(num); x = 5.0
2ndexempel:
float num = 5.25; int x; x = int(num); Output: 5
Typgjutning är uppdelad i två typer: implicit konvertering eller implicit typgjutning och explicit typomvandling eller explicit typcasting.
Implicit typgjutning eller implicit typkonvertering
- Det är känt som den automatiska typen av gjutning.
- Den konverteras automatiskt från en datatyp till en annan utan någon extern inblandning som programmerare eller användare. Det betyder att kompilatorn automatiskt konverterar en datatyp till en annan.
- All datatyp uppgraderas automatiskt till den största typen utan att förlora någon information.
- Det kan bara gälla i ett program om båda variablerna är kompatibla med varandra.
char - sort int -> int -> unsigned int -> long int -> float -> double -> long double, etc.
Obs: Implicit typcasting bör göras från låga till högre datatyper. Annars påverkar det den grundläggande datatypen, som kan förlora precision eller data, och kompilatorn kan visa en varning om detta.
Program för att använda den implicita typen casting i C++
Låt oss skapa ett exempel för att demonstrera gjutning av en variabel till en annan med hjälp av den implicita typen casting i C++.
#include using namespace std; int main () { short x = 200; int y; y = x; cout << ' Implicit Type Casting ' << endl; cout << ' The value of x: ' << x << endl; cout << ' The value of y: ' << y << endl; int num = 20; char ch = 'a'; int res = 20 + 'a'; cout << ' Type casting char to int data type ('a' to 20): ' << res << endl; float val = num + 'A'; cout << ' Type casting from int data to float type: ' << val << endl; return 0; } Produktion:
Implicit Type Casting The value of x: 200 The value of y: 200 Type casting char to int data type ('a' to 20): 117 Type casting from int data to float type: 85
I programmet ovan deklarerade vi att en kort datatypsvariabel x är 200 och en heltalsvariabel y. Efter det tilldelar vi x-värdet till y, och sedan konverterar kompilatorn automatiskt kort datavärde x till y, vilket returnerar y är 200.
I de följande uttrycken deklarerade vi att en variabel av typen int num är 20, och teckentypens variabel ch är 'a', vilket motsvarar ett heltalsvärde på 97. Sedan lägger vi till dessa två variabler för att utföra den implicita omvandlingen, som returnerar resultatet av uttrycket är 117.
som skapade skolan
På liknande sätt, i det tredje uttrycket, lägger vi till heltalsvariabeln num är 20, och teckenvariabeln ch är 65, och tilldelar sedan resultatet till flytvariabeln val. Således konverteras resultatet av uttrycket automatiskt till float-typen av kompilatorn.
Explicit typcasting eller explicit typkonvertering
- Det är också känt som den manuella typen av gjutning i ett program.
- Den castas manuellt av programmeraren eller användaren för att byta från en datatyp till en annan typ i ett program. Det innebär att en användare enkelt kan casta en data till en annan enligt kraven i ett program.
- Det kräver inte att man kontrollerar variablernas kompatibilitet.
- I denna casting kan vi uppgradera eller nedgradera datatypen för en variabel till en annan i ett program.
- Den använder cast-operatorn () för att ändra typen av en variabel.
Syntax av den explicita typen casting
(type) expression;
typ: Det representerar användardefinierade data som konverterar det givna uttrycket.
uttryck: Det representerar konstantvärdet, variabeln eller ett uttryck vars datatyp konverteras.
Till exempel har vi ett flytande tal är 4,534, och för att konvertera ett heltalsvärde, uttrycket som:
int num; num = (int) 4.534; // cast into int data type cout << num;
När ovanstående satser exekveras, kommer flyttalsvärdet att castas till en heltalsdatatyp med hjälp av cast-operatorn (). Och flytvärdet tilldelas ett heltal som trunkerar decimaldelen och visar endast 4 som heltalsvärde.
Program för att demonstrera användningen av den explicita typen av gjutning i C++
delsträngsmetod i java
Låt oss skapa ett enkelt program för att casta en typvariabel till en annan typ med hjälp av den explicita typen casting i programmeringsspråket C++.
#include using namespace std; int main () { // declaration of the variables int a, b; float res; a = 21; b = 5; cout << ' Implicit Type Casting: ' << endl; cout << ' Result: ' << a / b << endl; // it loses some information cout << '
Explicit Type Casting: ' << endl; // use cast () operator to convert int data to float res = (float) 21 / 5; cout << ' The value of float variable (res): ' << res << endl; return 0; } Produktion:
Implicit Type Casting: Result: 4 Explicit Type Casting: The value of float variable (res): 4.2
I programmet ovan tar vi två heltalsvariabler, a och b, vars värden är 21 och 2. Och dividera sedan a med b (21/2) som returnerar ett värde av 4 int-typ.
I det andra uttrycket deklarerar vi en flyttypvariabel res som lagrar resultaten av a och b utan att förlora några data med hjälp av cast-operatorn i den explicita typen cast-metoden.
Program för att gjuta dubbla data till int och float-typ med hjälp av cast-operatorn
Låt oss överväga ett exempel för att få arean av rektangeln genom att gjuta dubbla data till float och int typ i C++ programmering.
cast int till strängjava
#include using namespace std; int main () { // declaration of the variables double l, b; int area; // convert double data type to int type cout << ' The length of the rectangle is: ' <> l; cout << ' The breadth of the rectangle is: ' <> b; area = (int) l * b; // cast into int type cout << ' The area of the rectangle is: ' << area << endl; float res; // convert double data type to float type cout << '
The length of the rectangle is: ' << l << endl; cout << ' The breadth of the rectangle is: ' << b << endl; res = (float) l * b; // cast into float type cout << ' The area of the rectangle is: ' << res; return 0; } Produktion:
The length of the rectangle is: 57.3456 The breadth of the rectangle is: 12.9874 The area of the rectangle is: 740 The length of the rectangle is: 57.3456 The breadth of the rectangle is: 12.9874 The area of the rectangle is: 744.77
Några olika typer av typgjutning
I typcast finns det en cast-operatör som tvingar en datatyp att konverteras till en annan datatyp enligt programmets behov. C++ har fyra olika typer av rolloperator:
- Static_cast
- dynamic_cast
- const_cast
- reinterpret_cast
Statisk rollbesättning:
Static_cast är en enkel kompileringstid som konverterar eller castar en datatyp till en annan. Det betyder att den inte kontrollerar datatypen vid körning om den utförda casten är giltig eller inte. Programmeraren eller användaren har alltså ansvaret för att se till att konverteringen var säker och giltig.
Static_cast är tillräckligt kapabel för att kunna utföra alla konverteringar som utförs av den implicita casten. Och den utför även omvandlingar mellan pekare av klasser som är relaterade till varandra (uppsändning - > från härledd till basklass eller nedåtriktad - > från bas till härledd klass).
Syntax för den statiska casten
static_cast (expression);
Program för att demonstrera användningen av Static Cast
Låt oss skapa ett enkelt exempel för att använda statisk gjutning av typen casting i C++-programmering.
binär sökning
#include using namespace std; int main () { // declare a variable double l; l = 2.5 * 3.5 * 4.5; int tot; cout << ' Before using the static cast:' << endl; cout << ' The value of l = ' << l << endl; // use the static_cast to convert the data type tot = static_cast (l); cout << ' After using the static cast: ' << endl; cout << ' The value of tot = ' << tot << endl; return 0; } Produktion:
Before using the static cast: The value of l = 39.375 After using the static cast: The value of tot = 39
Dynamisk cast
dynamic_cast är en runtime cast-operator som används för att utföra konvertering av en typvariabel till en annan endast på klasspekare och referenser. Det betyder att den kontrollerar den giltiga castingen av variablerna vid körningstiden, och om castingen misslyckas returnerar den ett NULL-värde. Dynamisk gjutning är baserad på RTTI-mekanismen (Runtime Type Identification).
Program för att demonstrera användningen av Dynamic Cast i C++
Låt oss skapa ett enkelt program för att utföra dynamic_cast i programmeringsspråket C++.
#include using namespace std; class parent { public: virtual void print() { } }; class derived: public parent { }; int main () { // create an object ptr parent *ptr = new derived; // use the dynamic cast to convert class data derived* d = dynamic_cast (ptr); // check whether the dynamic cast is performed or not if ( d != NULL) { cout << ' Dynamic casting is done successfully'; } else { cout << ' Dynamic casting is not done successfully'; } } Produktion:
Dynamic casting is done successfully.
Omtolka Cast Type
Omtolkningen av typen reinterpret_cast används för att kasta en pekare till någon annan typ av pekare oavsett om den givna pekaren tillhör varandra eller inte. Det betyder att den inte kontrollerar om pekaren eller data som pekaren pekar på är densamma eller inte. Och den kastar också en pekare till en heltalstyp eller vice versa.
Syntax av typen reinterpret_cast
reinterpret_cast expression;
Program för att använda Reinterpret Cast i C++
Låt oss skriva ett program för att demonstrera konverteringen av en pekare med hjälp av omtolkningen i språket C++.
#include using namespace std; int main () { // declaration of the pointer variables int *pt = new int (65); // use reinterpre_cast operator to type cast the pointer variables char *ch = reinterpret_cast (pt); cout << ' The value of pt: ' << pt << endl; cout << ' The value of ch: ' << ch << endl; // get value of the defined variable using pointer cout << ' The value of *ptr: ' << *pt << endl; cout << ' The value of *ch: ' << *ch << endl; return 0; } Produktion:
The value of pt: 0x5cfed0 The value of ch: A The value of *ptr: 65 The value of *ch: A
Const Cast
något för bfs
Const_cast används för att ändra eller manipulera const-beteendet för källpekaren. Det betyder att vi kan utföra const på två sätt: ställa in en const-pekare till en icke-const-pekare eller ta bort eller ta bort const från en const-pekare.
Syntax av typen Const Cast
const_cast exp;
Program för att använda Const Cast i C++
Låt oss skriva ett program för att kasta en källpekare till en icke-cast-pekare med hjälp av const_cast i C++.
#include using namespace std; // define a function int disp(int *pt) { return (*pt * 10); } int main () { // declare a const variable const int num = 50; const int *pt = # // get the address of num // use const_cast to chnage the constness of the source pointer int *ptr = const_cast (pt); cout << ' The value of ptr cast: ' << disp(ptr); return 0; } Produktion:
The value of ptr cast: 500