In diesem Abschnitt wird die Typumwandlung der Variablen in der Programmiersprache C++ erläutert. Unter Typumwandlung versteht man die Konvertierung eines Datentyps in einen anderen in einem Programm. Die Typumwandlung kann auf zwei Arten erfolgen: automatisch durch den Compiler und manuell durch den Programmierer oder Benutzer. Type Casting wird auch als Type Conversion bezeichnet.
Angenommen, die angegebenen Daten sind vom Typ Integer und wir möchten sie in den Typ Float konvertieren. Wir müssen also int-Daten manuell in den Float-Typ umwandeln, und diese Art der Umwandlung wird in C++ als Typumwandlung bezeichnet.
int num = 5; float x; x = float(num); x = 5.0
2ndBeispiel:
float num = 5.25; int x; x = int(num); Output: 5
Die Typumwandlung ist in zwei Typen unterteilt: Implizite Konvertierung oder implizite Typumwandlung und explizite Typkonvertierung oder explizite Typumwandlung.
Implizite Typumwandlung oder implizite Typkonvertierung
- Es ist als automatischer Typguss bekannt.
- Die Konvertierung von einem Datentyp in einen anderen erfolgt automatisch, ohne dass ein externer Eingriff durch einen Programmierer oder Benutzer erforderlich ist. Das bedeutet, dass der Compiler automatisch einen Datentyp in einen anderen konvertiert.
- Alle Datentypen werden automatisch auf den größten Typ aktualisiert, ohne dass Informationen verloren gehen.
- Es kann nur dann in einem Programm gelten, wenn beide Variablen miteinander kompatibel sind.
char - sort int -> int -> unsigned int -> long int -> float -> double -> long double, etc.
Hinweis: Die implizite Typumwandlung sollte von niedrigen zu höheren Datentypen erfolgen. Andernfalls wirkt es sich auf den grundlegenden Datentyp aus, der möglicherweise an Präzision oder Daten verliert, und der Compiler gibt möglicherweise eine entsprechende Warnung aus.
Programm zur Verwendung der impliziten Typumwandlung in C++
Lassen Sie uns ein Beispiel erstellen, um die Umwandlung einer Variablen in eine andere mithilfe der impliziten Typumwandlung in C++ zu demonstrieren.
#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; } Ausgabe:
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
Im obigen Programm haben wir eine kurze Datentypvariable x mit 200 und eine ganzzahlige Variable y deklariert. Danach weisen wir den x-Wert dem y zu, und dann konvertiert der Compiler automatisch den kurzen Datenwert x in den y-Wert, was zurückgibt, dass y 200 ist.
sortierte Arrayliste in Java
In den nächsten Ausdrücken haben wir eine int-Typvariable num als 20 und die Zeichentypvariable ch als „a“ deklariert, was einem ganzzahligen Wert von 97 entspricht. Anschließend fügen wir diese beiden Variablen hinzu, um die implizite Konvertierung durchzuführen. was das Ergebnis des Ausdrucks zurückgibt, ist 117.
In ähnlicher Weise fügen wir im dritten Ausdruck die Ganzzahlvariable num mit dem Wert 20 und die Zeichenvariable ch mit dem Wert 65 hinzu und weisen das Ergebnis dann der Gleitkommavariablen val zu. Somit wird das Ergebnis des Ausdrucks vom Compiler automatisch in den Float-Typ konvertiert.
Explizite Typumwandlung oder explizite Typkonvertierung
- Es wird auch als manuelle Typumwandlung in einem Programm bezeichnet.
- Es wird vom Programmierer oder Benutzer manuell umgewandelt, um in einem Programm von einem Datentyp zu einem anderen zu wechseln. Dies bedeutet, dass ein Benutzer je nach Anforderung in einem Programm problemlos Daten in andere umwandeln kann.
- Eine Überprüfung der Kompatibilität der Variablen ist nicht erforderlich.
- Bei diesem Casting können wir den Datentyp einer Variablen in einem Programm auf eine andere herauf- oder herabstufen.
- Es verwendet den cast()-Operator, um den Typ einer Variablen zu ändern.
Syntax der expliziten Typumwandlung
(type) expression;
Typ: Es stellt die benutzerdefinierten Daten dar, die den angegebenen Ausdruck konvertieren.
Ausdruck: Es stellt den konstanten Wert, die Variable oder einen Ausdruck dar, dessen Datentyp konvertiert wird.
Zum Beispiel haben wir eine Gleitkommazahl von 4,534, und um einen ganzzahligen Wert umzuwandeln, lautet die Anweisung wie folgt:
int num; num = (int) 4.534; // cast into int data type cout << num;
Wenn die obigen Anweisungen ausgeführt werden, wird der Gleitkommawert mithilfe des Cast()-Operators in einen ganzzahligen Datentyp umgewandelt. Und der Float-Wert wird einer Ganzzahl zugewiesen, die den Dezimalteil abschneidet und nur 4 als Ganzzahlwert anzeigt.
Programm zur Demonstration der Verwendung der expliziten Typumwandlung in C++
Lassen Sie uns ein einfaches Programm erstellen, um eine Typvariable mithilfe der expliziten Typumwandlung in der Programmiersprache C++ in einen anderen Typ umzuwandeln.
#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; } Ausgabe:
Implicit Type Casting: Result: 4 Explicit Type Casting: The value of float variable (res): 4.2
Im obigen Programm nehmen wir zwei ganzzahlige Variablen, a und b, deren Werte 21 und 2 sind. Und dividieren dann a durch b (21/2), was einen Wert vom Typ 4 int zurückgibt.
Im zweiten Ausdruck deklarieren wir mithilfe des Umwandlungsoperators in der expliziten Typumwandlungsmethode eine Variable vom Typ Float, res, die die Ergebnisse von a und b ohne Datenverlust speichert.
Programm zum Umwandeln doppelter Daten in die Typen „int“ und „float“ mithilfe des Umwandlungsoperators
MySQL zeigt Benutzer an
Betrachten wir ein Beispiel, um die Fläche des Rechtecks zu ermitteln, indem in der C++-Programmierung doppelte Daten in die Typen float und int umgewandelt werden.
#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; } Ausgabe:
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
Einige verschiedene Arten des Type Castings
Bei der Typumwandlung gibt es einen Umwandlungsoperator, der die Konvertierung eines Datentyps in einen anderen Datentyp entsprechend den Anforderungen des Programms erzwingt. C++ verfügt über vier verschiedene Typen des Cast-Operators:
- Static_cast
- dynamischer_cast
- const_cast
- reinterpret_cast
Statische Besetzung:
slf4j vs. log4j
Der static_cast ist ein einfacher Cast zur Kompilierungszeit, der einen Datentyp in einen anderen konvertiert oder umwandelt. Das bedeutet, dass der Datentyp zur Laufzeit nicht überprüft wird, ob die durchgeführte Umwandlung gültig ist oder nicht. Daher ist der Programmierer oder Benutzer dafür verantwortlich, sicherzustellen, dass die Konvertierung sicher und gültig war.
Der static_cast ist leistungsfähig genug, um alle von der impliziten Umwandlung durchgeführten Konvertierungen durchzuführen. Und es führt auch die Konvertierungen zwischen Zeigern von Klassen durch, die miteinander in Beziehung stehen (Upcast -> von der abgeleiteten zur Basisklasse oder Downcast -> von der Basis zur abgeleiteten Klasse).
Syntax der statischen Besetzung
static_cast (expression);
Programm zur Demonstration der Verwendung des Static Cast
Lassen Sie uns ein einfaches Beispiel erstellen, um die statische Umwandlung des Typumwandlungstyps in der C++-Programmierung zu verwenden.
#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; } Ausgabe:
Before using the static cast: The value of l = 39.375 After using the static cast: The value of tot = 39
Dynamische Besetzung
Der dynamische_cast ist ein Laufzeitumwandlungsoperator, der zur Konvertierung einer Typvariablen in eine andere nur für Klassenzeiger und Referenzen verwendet wird. Das bedeutet, dass die gültige Umwandlung der Variablen zur Laufzeit überprüft wird und, wenn die Umwandlung fehlschlägt, ein NULL-Wert zurückgegeben wird. Dynamisches Casting basiert auf dem RTTI-Mechanismus (Runtime Type Identification).
Programm zur Demonstration der Verwendung des Dynamic Cast in C++
Lassen Sie uns ein einfaches Programm erstellen, um den Dynamic_cast in der Programmiersprache C++ durchzuführen.
#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'; } } Ausgabe:
Dynamic casting is done successfully.
Besetzungstyp neu interpretieren
Die Typumwandlung reinterpret_cast wird verwendet, um einen Zeiger in einen beliebigen anderen Zeigertyp umzuwandeln, unabhängig davon, ob die angegebenen Zeiger zueinander gehören oder nicht. Das bedeutet, dass nicht geprüft wird, ob der Zeiger oder die Daten, auf die der Zeiger zeigt, gleich sind oder nicht. Außerdem wird ein Zeiger auf einen Integer-Typ umgewandelt oder umgekehrt.
Syntax des Typs reinterpret_cast
reinterpret_cast expression;
Programm zur Verwendung des Reinterpret Cast in C++
Schreiben wir ein Programm, um die Konvertierung eines Zeigers mithilfe der Neuinterpretation in der Sprache C++ zu demonstrieren.
#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; } Ausgabe:
The value of pt: 0x5cfed0 The value of ch: A The value of *ptr: 65 The value of *ch: A
Const-Besetzung
Der const_cast wird verwendet, um das const-Verhalten des Quellzeigers zu ändern oder zu manipulieren. Das bedeutet, dass wir die Konstante auf zwei Arten ausführen können: einen Konstantenzeiger auf einen Nicht-Konstantenzeiger setzen oder die Konstante aus einem Konstantenzeiger löschen oder entfernen.
nicht
Syntax vom Typ Const Cast
const_cast exp;
Programm zur Verwendung des Const Cast in C++
Schreiben wir ein Programm, um mithilfe von const_cast in C++ einen Quellzeiger in einen nicht umgewandelten Zeiger umzuwandeln.
#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; } Ausgabe:
The value of ptr cast: 500