In deze sectie wordt het type casting van de variabelen in de programmeertaal C++ besproken. Type casting verwijst naar de conversie van het ene gegevenstype naar het andere in een programma. Typecasting kan op twee manieren: automatisch door de compiler en handmatig door de programmeur of gebruiker. Typecasting wordt ook wel typeconversie genoemd.
Stel bijvoorbeeld dat de gegeven gegevens van het type geheel getal zijn en dat we deze naar het float-type willen converteren. We moeten dus handmatig int-gegevens naar het float-type casten, en dit type casting wordt in C++ Type Casting genoemd.
int num = 5; float x; x = float(num); x = 5.0
2nlvoorbeeld:
float num = 5.25; int x; x = int(num); Output: 5
Type Casting is onderverdeeld in twee typen: Impliciete conversie of Impliciete Type Casting en Expliciete Type Conversie of Expliciete Type Casting.
Impliciete typecasting of impliciete typeconversie
- Het staat bekend als het automatische typegieten.
- Het werd automatisch geconverteerd van het ene gegevenstype naar het andere, zonder enige externe tussenkomst, zoals een programmeur of gebruiker. Het betekent dat de compiler automatisch het ene gegevenstype naar het andere converteert.
- Alle gegevenstypen worden automatisch geüpgraded naar het grootste type zonder dat er informatie verloren gaat.
- Het kan alleen in een programma worden toegepast als beide variabelen compatibel zijn met elkaar.
char - sort int -> int -> unsigned int -> long int -> float -> double -> long double, etc.
Opmerking: Impliciete typecasting moet worden uitgevoerd van lage naar hogere gegevenstypen. Anders heeft dit invloed op het fundamentele gegevenstype, waardoor de nauwkeurigheid of gegevens verloren kunnen gaan, en de compiler kan hierover een waarschuwing geven.
Programma om het impliciete type casting in C++ te gebruiken
Laten we een voorbeeld maken om het casten van de ene variabele naar de andere te demonstreren met behulp van de impliciete typecasting in 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; } Uitgang:
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
In het bovenstaande programma hebben we een korte gegevenstypevariabele x 200 en een geheel getalvariabele y gedeclareerd. Daarna wijzen we de x-waarde toe aan de y, en vervolgens converteert de compiler automatisch de korte gegevenswaarde x naar de y, wat resulteert in y is 200.
In de volgende uitdrukkingen hebben we aangegeven dat een int-typevariabele num 20 is, en dat de tekentypevariabele ch 'a' is, wat overeenkomt met een geheel getal van 97. En vervolgens voegen we deze twee variabelen toe om de impliciete conversie uit te voeren, wat het resultaat van de uitdrukking retourneert is 117.
converteer tekenreeks naar geheel getal
Op dezelfde manier voegen we in de derde uitdrukking de integer-variabele num is 20 toe, en de karaktervariabele ch is 65, en wijzen het resultaat vervolgens toe aan de float-variabele val. Het resultaat van de expressie wordt dus door de compiler automatisch geconverteerd naar het float-type.
Expliciete typecasting of expliciete typeconversie
- Het wordt ook wel het handmatig typen van typen in een programma genoemd.
- Het wordt handmatig door de programmeur of gebruiker gegoten om van het ene gegevenstype naar het andere type in een programma te veranderen. Het betekent dat een gebruiker eenvoudig de ene gegevens naar de andere kan casten, afhankelijk van de vereisten in een programma.
- Het vereist geen controle van de compatibiliteit van de variabelen.
- Bij deze casting kunnen we het gegevenstype van de ene variabele naar de andere in een programma upgraden of downgraden.
- Het gebruikt de operator cast () om het type van een variabele te wijzigen.
Syntaxis van het expliciete type casting
(type) expression;
type: Het vertegenwoordigt de door de gebruiker gedefinieerde gegevens die de gegeven uitdrukking converteren.
uitdrukking: Het vertegenwoordigt de constante waarde, variabele of een expressie waarvan het gegevenstype wordt geconverteerd.
We hebben bijvoorbeeld een zwevend aanwijsgetal van 4,534, en om een geheel getal te converteren, luidt de instructie als volgt:
int num; num = (int) 4.534; // cast into int data type cout << num;
Wanneer de bovenstaande instructies worden uitgevoerd, wordt de drijvende-kommawaarde omgezet in een geheel getalgegevenstype met behulp van de cast () operator. En de float-waarde wordt toegewezen aan een geheel getal, waarbij het decimale gedeelte wordt afgekapt en slechts 4 als geheel getal wordt weergegeven.
Programma om het gebruik van expliciete typecasting in C++ te demonstreren
Java-lijstknooppunt
Laten we een eenvoudig programma maken om de ene typevariabele naar een ander type te casten met behulp van de expliciete typecasting in de programmeertaal 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; } Uitgang:
Implicit Type Casting: Result: 4 Explicit Type Casting: The value of float variable (res): 4.2
In het bovenstaande programma nemen we twee gehele variabelen, a en b, waarvan de waarden 21 en 2 zijn. En dan delen we a door b (21/2), wat een waarde van het type 4 int oplevert.
In de tweede uitdrukking declareren we een float-typevariabele res die de resultaten van a en b opslaat zonder gegevens te verliezen met behulp van de cast-operator in de expliciete type cast-methode.
Programma om dubbele gegevens naar int- en float-type te casten met behulp van de cast-operator
Laten we een voorbeeld bekijken om de oppervlakte van de rechthoek te bepalen door dubbele gegevens in het float- en int-type te gieten in C++-programmering.
Python is numeriek
#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; } Uitgang:
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
Enkele verschillende soorten Type Casting
Bij type cast is er een cast-operator die dwingt om één gegevenstype te converteren naar een ander gegevenstype, afhankelijk van de behoeften van het programma. C++ heeft vier verschillende typen cast-operator:
- Statische_cast
- dynamische_cast
- const_cast
- herinterpreteer_cast
Statische cast:
De static_cast is een eenvoudige cast tijdens het compileren die het ene gegevenstype naar het andere converteert of cast. Dit betekent dat het tijdens runtime niet controleert op het gegevenstype of de uitgevoerde cast geldig is of niet. De programmeur of gebruiker heeft dus de verantwoordelijkheid om ervoor te zorgen dat de conversie veilig en geldig was.
De static_cast is capabel genoeg om alle conversies uit te voeren die door de impliciete cast worden uitgevoerd. En het voert ook de conversies uit tussen pointers van klassen die aan elkaar gerelateerd zijn (upcast -> van afgeleide naar basisklasse of downcast -> van basis naar afgeleide klasse).
Syntaxis van de statische cast
static_cast (expression);
Programma om het gebruik van de Static Cast te demonstreren
Laten we een eenvoudig voorbeeld maken om de statische cast van het type casting te gebruiken in C++-programmering.
d flip-flop
#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; } Uitgang:
Before using the static cast: The value of l = 39.375 After using the static cast: The value of tot = 39
Dynamische cast
De dynamic_cast is een runtime cast-operator die wordt gebruikt om conversie van de ene typevariabele naar de andere uit te voeren, alleen op klassenaanwijzers en -referenties. Het betekent dat het de geldige casting van de variabelen tijdens de runtime controleert, en als het casten mislukt, retourneert het een NULL-waarde. Dynamisch casten is gebaseerd op het RTTI-mechanisme (Runtime Type Identification).
Programma om het gebruik van de Dynamic Cast in C++ te demonstreren
Laten we een eenvoudig programma maken om de dynamic_cast uit te voeren in de programmeertaal 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'; } } Uitgang:
Dynamic casting is done successfully.
Herinterpreteer het Cast-type
De reinterpret_cast type casting wordt gebruikt om een pointer naar een ander type pointer te casten, ongeacht of de gegeven pointer bij elkaar hoort of niet. Het betekent dat er niet wordt gecontroleerd of de aanwijzer of de gegevens waarnaar de aanwijzer verwijst, hetzelfde zijn of niet. En het wierp ook een verwijzing naar een geheel getaltype of omgekeerd.
Syntaxis van het type reinterpret_cast
reinterpret_cast expression;
Programma om de Reinterpret Cast in C++ te gebruiken
Laten we een programma schrijven om de conversie van een pointer te demonstreren met behulp van de herinterpretatie in C++-taal.
#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; } Uitgang:
The value of pt: 0x5cfed0 The value of ch: A The value of *ptr: 65 The value of *ch: A
Const Cast
Java-scanner volgende
De const_cast wordt gebruikt om het const-gedrag van de bronaanwijzer te wijzigen of te manipuleren. Het betekent dat we de const op twee manieren kunnen uitvoeren: een const-pointer instellen op een niet-const-pointer of de const verwijderen of verwijderen uit een const-pointer.
Syntaxis van het Const Cast-type
const_cast exp;
Programma om de Const Cast in C++ te gebruiken
Laten we een programma schrijven om een bronaanwijzer naar een niet-cast-aanwijzer te casten met behulp van de const_cast in 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; } Uitgang:
The value of ptr cast: 500