Menü

Typkonvertierungen in C ++

type conversions c

Versuchen Sie Unser Instrument, Um Probleme Zu Beseitigen

Schauen Sie sich die verschiedenen in C ++ unterstützten Typkonvertierungen an.

Wir hoffen, dass Sie alle Datentypen kennen, die in C ++ aus unseren früheren Tutorials verfügbar sind. Manchmal kann ein Bedarf entstehen, so dass wir einen Typ in einen anderen konvertieren müssen. Dies wird als Typkonvertierung oder Typguss bezeichnet.

In diesem Tutorial werden die verschiedenen in C ++ unterstützten Typkonvertierungen erläutert.

wie man apk dateien unter windows öffnet

=> Klicken Sie hier für den kostenlosen C ++ - Kurs.

Typkonvertierungen in C ++

Was du lernen wirst:

Typkonvertierungen

C ++ unterstützt zwei Arten von Typkonvertierungen:

  • Implizite Typkonvertierung: Die implizite Typkonvertierung erfolgt automatisch. Der Benutzer stört diese Art der Konvertierung nicht und der Compiler führt die Konvertierung direkt durch. Die Konvertierung erfolgt normalerweise, wenn im Ausdruck mehr als ein Datentyp vorhanden ist. Bei dieser Art der Konvertierung besteht jedoch im Allgemeinen die Möglichkeit eines Datenverlusts, eines Zeichenverlusts oder eines Datenüberlaufs.
  • Explizite Typkonvertierung: Die explizite Typkonvertierung ist benutzerdefiniert und wird normalerweise als 'Typumwandlung' bezeichnet. Hier wandelt oder konvertiert der Benutzer je nach Anforderung einen Wert eines Datentyps in einen anderen. Diese Art von Konvertierungen ist sicherer.

Jetzt werden wir beide Arten der Typkonvertierung im Detail sehen.

Implizite Konvertierung

Bei der impliziten Konvertierung führt der Compiler die Konvertierungen von einem Datentyp in einen anderen durch, wenn ein Ausdruck mehr als einen Datentyp hat. Um Datenverlust zu vermeiden, werden alle Variablen der anderen Datentypen in den größten Datentyp konvertiert. Dies nennt man Werbung.

Lassen Sie uns die implizite Konvertierung anhand eines Codebeispiels verstehen.

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

float val (10 + 'a') = 107

var_int = 1000

Das obige Codebeispiel zeigt die implizite Konvertierung. Wir haben eine Ganzzahl- und eine Zeichenvariable mit den Werten 10 bzw. 'A' deklariert. Wenn wir diese beiden Variablen addieren, findet eine implizite Konvertierung statt.

Da Ganzzahl der größere Typ in diesem Ausdruck ist, wird der Zeichenvariablenwert 'A' in sein Ganzzahläquivalent konvertiert, d. H. Den Wert 65 (ASCII-Wert). Somit ist das Ergebnis des Ausdrucks 75.

Im nächsten Ausdruck fügen wir eine Ganzzahl und ein Zeichen ('a' -> 97) hinzu und weisen das Ergebnis dann float zu. Somit wird das Ergebnis des Ausdrucks vom Compiler implizit in float konvertiert.

Im dritten Ausdruck wird eine kurze int-Variable implizit in eine Ganzzahl konvertiert.

Hinweis : Wenn der Compiler bei impliziten Konvertierungen einen potenziellen Datenverlust feststellt, blinkt möglicherweise eine entsprechende Warnung.

Explizite Konvertierung

Die explizite Konvertierung wird auch als 'Typumwandlung' bezeichnet, da wir einen Datentyp in einen anderen Datentyp 'umwandeln'. Hier definieren die Benutzer das Casting explizit, im Gegensatz zur impliziten Konvertierung, bei der der Compiler die Konvertierung intern durchführt.

Wir können die explizite Konvertierung auf zwei Arten durchführen:

# 1) Verwenden des Zuweisungsoperators

Explizite Konvertierung oder Typumwandlung unter Verwendung des Zuweisungsoperators in einer Weise wird mit Nachdruck durchgeführt. Hier wandeln oder konvertieren wir einen Datentyp mithilfe des Zuweisungsoperators in einen anderen Datentyp.

Die allgemeine Syntax lautet:

(data type) expression;

Das folgende Beispiel erklärt dies:

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

Bei dieser Art von Casting verwenden wir einen „Cast-Operator“, bei dem es sich um einen unären Operator handelt, um von einem Typ zu einem anderen zu wechseln.

Arten des Gießens

Abhängig vom verwendeten Cast-Operator gibt es folgende Casting-Arten:

# 1) Statische Besetzung

Die statische Umwandlung ist die einfachste unter allen Typumwandlungen mit dem Besetzungsoperator . Die statische Umwandlung kann alle Konvertierungen ausführen, die implizit ausgeführt werden. Es führt auch Konvertierungen zwischen Zeigern von Klassen durch, die miteinander in Beziehung stehen (Upcast -> von abgeleitet zu Basis oder Downcast -> von Basis zu abgeleitet).

Abgesehen von den oben aufgeführten Konvertierungen kann die statische Umwandlung auch jeden Zeiger in void * konvertieren.

Die statische Umwandlung ist die kompilierte Zeitumwandlung. Dies bedeutet, dass zur Laufzeit keine Überprüfung durchgeführt wird, um festzustellen, ob die durchgeführte Besetzung gültig ist oder nicht. Daher bleibt es die Verantwortung des Programmierers, sicherzustellen, dass die Konvertierung sicher und gültig war.

Mit anderen Worten, der Benutzer muss sicherstellen, dass das konvertierte Objekt in Bezug auf den Zieldatentyp voll war.

Wir geben eine statische Umwandlung wie folgt an:

static_cast (expression)

Lassen Sie uns die statische Besetzung anhand eines Beispiels verstehen.

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

Im obigen Beispiel haben wir den Code geringfügig geändert, um eine Zeichenvariable mit dem Wert 'A' aufzunehmen. Dann deklarieren wir einen Ganzzahlzeiger und wenden eine statische Umwandlung an, um ein Zeichen in einen Ganzzahlzeiger umzuwandeln.

Wenn wir dieses Programm kompilieren, erhalten wir die folgende Ausgabe.

In der Funktion 'int main ()':
10:35: Fehler: Ungültiger static_cast vom Typ 'char *' zum Typ 'int *'

Das Programm gibt einen Fehler für die durchgeführte statische Umwandlung aus, da diese ungültig ist. Daher erlaubt die statische Umwandlung nur gültige Typumwandlungen oder Konvertierungen und gibt einen Fehler aus, wenn wir versuchen, eine unerwünschte Typumwandlung durchzuführen.

# 2) Dynamische Besetzung

Dynamische Umwandlung ist eine Laufzeitumwandlung, die durchgeführt wird, um die Gültigkeit der Umwandlung zu überprüfen. Die dynamische Umwandlung wird nur für Klassenzeiger und Referenzen durchgeführt. Der Ausdruck gibt einen NULL-Wert zurück, wenn die Umwandlung fehlschlägt.

Die dynamische Besetzung verwendet einen Mechanismus, der als bekannt ist RTTI (Runtime Type Identification) . RTTI stellt alle Informationen zum Datentyp des Objekts zur Laufzeit zur Verfügung und ist nur für Klassen verfügbar, die mindestens eine virtuelle Funktion haben (polymorpher Typ). Mit RTTI kann der Objekttyp zur Laufzeit oder zum Zeitpunkt der Ausführung ermittelt werden.

Versuchen wir ein Beispiel, um die dynamische Besetzung zu verstehen.

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

In diesem Programm haben wir zwei Klassen definiert, Basis mit einer virtuellen Funktion und abgeleitet mit einer Basisklasse, Basis.

In der Hauptfunktion erstellen wir ein abgeleitetes Klassenobjekt, auf das der Basisklassenzeiger zeigt. Dann führen wir dynamic_cast für den Basiszeiger aus, der auf eine abgeleitete Klasse zeigt, um ihn in einen abgeleiteten Klassenzeiger umzuwandeln.

Wie in der Basisklasse ist die Basis polymorph (enthält eine virtuelle Funktion), der dynamic_cast ist erfolgreich.

Hinweis: Wenn wir die virtuelle Funktion aus der obigen Klasse entfernen, schlägt dynamic_cast fehl, da RTTI-Informationen für die Objekte nicht verfügbar sind.

Die dynamische Besetzung hat zur Laufzeit einen gewissen Aufwand an Typensicherheit.

# 3) Besetzung neu interpretieren

Diese Art der Besetzung ist am gefährlichsten, da sie für jede Art von Objekt funktioniert, ohne dass die Klassen miteinander in Beziehung stehen.

Reintepret_cast funktioniert mit beliebigen Zeigern und konvertiert einen Zeiger eines beliebigen Typs in einen anderen Typ, unabhängig davon, ob die Zeiger miteinander in Beziehung stehen oder nicht. Es wird nicht geprüft, ob der Zeiger oder die Daten, auf die der Zeiger zeigt, identisch sind oder nicht.

Der Cast-Operator verwendet nur einen Parameter, den zu konvertierenden Quellzeiger, und gibt keinen Wert zurück. Es konvertiert einfach den Zeigertyp.

Wir sollten nicht verwenden, es sei denn, dies ist erforderlich. Normalerweise typisieren wir den Quellzeiger auf seinen ursprünglichen Typ.

Wir arbeiten hauptsächlich mit Bits. Bei Verwendung für Boolesche Werte werden Boolesche Werte in ganzzahlige Werte konvertiert, d. H. 1 für wahr und 0 für falsch.

Sehen wir uns ein Beispiel für eine Neuinterpretation an:

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

Ausgabe:

0x3ef3090
zu
97
zu

Im obigen Beispiel haben wir einen Ganzzahlzeiger ptr deklariert, der auf den Wert 97 zeigt. Als Nächstes deklarieren wir einen Zeichenzeiger ch und setzen ptr mit.

wie man ein Selengitter aufbaut

Als nächstes drucken wir verschiedene Werte. Das erste, das wir drucken, ist ptr, das auf eine ganzzahlige Position zeigt. Daher wird eine Adresse gedruckt.

Der nächste Wert ch enthält den Wert 97 und gibt daher 'a' aus, was einem ASCII-Äquivalent von 97 entspricht. Der nächste Wert „* ptr“ enthält den Wert 97, während „* ch“ das ASCII-Äquivalent von 97 enthält, dh 'a', wie es mit verwendet wird der reinterpret_cast.

# 4) Const Cast

Der Cast-Operator wird verwendet, um die Konstanz des Quellzeigers zu ändern oder zu manipulieren. Mit Manipulation meinen wir, dass es entweder sein kann, die Konstanz auf einen Nicht-Konstanten-Zeiger zu setzen oder die Konstanz von einem Konstanten-Zeiger zu entfernen.

Voraussetzung für eine erfolgreiche Umwandlung des Operators ist, dass der Zeiger und die Quelle, die umgewandelt wird, vom gleichen Typ sind.

Nehmen wir ein Beispiel, um dies zu verstehen.

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

In diesem Beispiel sehen wir, dass die Funktion 'printVal' einen nicht konstanten Zeiger akzeptiert. In der Hauptfunktion haben wir dem const-Zeiger ptr eine const-Variable 'value' zugewiesen.

Um diesen const-Zeiger an die Funktion printVal zu übergeben, setzen wir ihn durch Anwenden um, um die constness zu entfernen. Dann übergeben wir den Zeiger ptr_cast an die Funktion, um die gewünschten Ergebnisse zu erhalten.

Fazit

Damit werden wir dieses Thema der Typkonvertierung in C ++ abschließen. Wir haben alles über implizite und explizite Konvertierungen gesehen, die in C ++ verwendet werden.

Man sollte sich jedoch bewusst sein, dass Konvertierungen oder Typografien nur dann mit Bedacht angewendet werden sollten, wenn Daten erforderlich sind, um Datenverlust und andere derartige Schwierigkeiten zu vermeiden.

=> Sehen Sie sich hier den C ++ - Schulungsleitfaden für Anfänger an.

Literatur-Empfehlungen

^