Static_Cast vs. Dynamic_Cast in C++

Das Konvertieren eines Wertes von einem bestimmten Datentyp in einen anderen wird als Typumwandlung oder Typkonvertierung bezeichnet. Sie können damit die Interpretation und Darstellung eines Wertes ändern, um ihn mit einem anderen Datentyp kompatibel zu machen.

Typumwandlung kann grob in zwei Typen unterteilt werden: implizite Umwandlung und explizite Umwandlung. Wenn ein Wert von einem Typ in einen anderen konvertiert werden muss, wird die explizite Umwandlung vom Programmierer durchgeführt, der die Umwandlungsoperatoren verwendet. In C++ stehen mehrere Umwandlungsoperatoren für explizite Umwandlung zur Verfügung: static_cast, dynamic_cast, reinterpret_cast und const_cast.

Dieser Beitrag behandelt nur „static_cast“ und „dynamic_cast“.

Statisches Casting in C++

Eine explizite Typkonvertierung zwischen zwei kompatiblen Typen wird durch den Casting-Operator durchgeführt, der in C++ als „static_cast“ bekannt ist. Es handelt sich um eine Konvertierung zur Kompilierungszeit, mit der Sie einen Wert eines Typs in einen anderen konvertieren können, vorausgesetzt, die Konvertierung ist definiert und wird von der Sprache als sicher angesehen.

Die Syntax für „static_cast“ lautet wie folgt:

static_cast(Ausdruck)

Dabei stellt „new_type“ den gewünschten Typ dar, in den Sie den Ausdruck konvertieren möchten. Als Ausdruck kann eine Variable, eine Konstante oder jeder gültige C++-Ausdruck verwendet werden.

Es gibt zahlreiche Konvertierungstypen, für die „static_cast“ verwendet werden kann. Es kann zwischen verschiedenen numerischen Typen konvertieren, beispielsweise einen int in einen double oder einen float in einen int, solange die Konvertierung wohldefiniert ist. Es ermöglicht Ihnen, die Zeiger oder Referenzen zwischen den verwandten Typen in einer Hierarchie zu konvertieren, beispielsweise die Zeiger der Basisklasse in die Zeiger der abgeleiteten Klasse oder umgekehrt. Viele andere Operationen können damit durchgeführt werden.

Es ist wichtig zu beachten, dass „static_cast“ nur eine begrenzte Anzahl von Konvertierungen durchführt und für sichere und wohldefinierte Konvertierungen gedacht ist. Für spezialisiertere Konvertierungen oder Typmanipulationen bietet C++ andere Casting-Operatoren wie dynamic_cast.

Sehen wir uns eine praktische Implementierung von „static_cast“ im C++-Programm an.

Konvertieren von Float in Int

Das erste Programm konvertiert einen Float-Wert mittels statischem Casting in einen Int-Wert.

#include

Namespace std verwenden;

int main()

{

Gleitkommawert = 14,2;

: In diesem Beispiel wird Y als statischer Cast verwendet.

cout << "\nDer Wert von Y ist: " << Y;}

Die Header-Dateien werden zunächst in das Programm eingebunden. Der Treibercode startet, wenn wir die Funktion main() aufrufen. Wir initialisieren eine Float-Variable „val“ auf den Wert „14.2“.

Nun konvertieren wir diesen Float-Wert in den Datentyp „int“, indem wir „static_cast“ verwenden. Eine „Y“-Variable mit dem Typ „int“ wird deklariert und mit der Ausgabe von static_cast versehen. Dabei ist „int“ der gewünschte Datentyp für die Konvertierung. In den runden Klammern wird die Variable angegeben, die den zu transformierenden Wert speichert. „static_cast“ nimmt also den Wert aus der Variable „val“, konvertiert ihn in den gewünschten Typ, nämlich „int“, und speichert ihn in der Variable „Y“. Beachten Sie, dass der Wert nach Punkt (.2) verloren geht, da wir ihn in den Typ „int“ konvertieren. Der in der Variable „Y“ gespeicherte „int“-Wert wird mithilfe der Anweisung „cout“ angezeigt.

Hier ist der Ausgabewert „int“:

Konvertieren des Int-Zeigers in einen generischen Typ

Wir verwenden jetzt „static_cast“, um den Zeiger vom Typ „int“ in einem C++-Programm in ein void* zu konvertieren.

int main()

{

int* p1 = neues int(5);

void*p2 = static_cast(p1);

}

In diesem Beispiel wird „p1“, ein Zeiger auf int, mit „static_cast“ explizit in einen void* p2 umgewandelt. Der Zeigertyp wird in einen generischen void*-Zeiger umgewandelt, der jede Art von Zeiger speichern kann.

Obwohl „static_cast“ zahlreiche Anwendungen hat, haben wir hier nur die Grundlagen behandelt.

Dynamisches Casting in C++

Ein weiterer Casting-Operator in C++, der hauptsächlich zur Laufzeittypprüfung und Typkonvertierung innerhalb polymorpher Klassenhierarchien verwendet wird, ist der „dynamic_cast“. Er ermöglicht es Ihnen, die Zeiger oder Referenzen der Basisklasse sicher in die Zeiger oder Referenzen der abgeleiteten Klasse zu ändern und umgekehrt.

Die Syntax für „dynamic_cast“ lautet wie folgt:

dynamic_cast(Ausdruck)

Dabei stellt „new_type“ den gewünschten Typ dar, in den Sie den Ausdruck konvertieren möchten. Im Ausdruck kann auf eine polymorphe Klasse verwiesen werden.

Der „dynamic_cast“ prüft, ob das Objekt, auf das der Ausdruck zeigt, ein vollständiges Objekt des Zieltyps ist. Wenn das Objekt nicht dem Zieltyp entspricht und die Basisklasse mindestens eine virtuelle Funktion enthält, gibt der „dynamic_cast“ einen Nullzeiger zurück. Darüber hinaus prüft er, ob der Objektausdruck auf ein vollständiges Objekt des gewünschten Typs verweist. Wenn das Objekt nicht dem gewünschten Typ angehört und die Basisklasse mindestens eine virtuelle Funktion enthält, wirft der „dynamic_cast“ die Ausnahme „std::bad_cast“ aus.

Es ist wichtig zu beachten, dass „dynamic_cast“ für die Verwendung mit polymorphen Klassen vorgesehen ist, d. h. Klassen, die mindestens eine virtuelle Funktion enthalten. Wenn in der Basisklasse keine virtuellen Funktionen vorhanden sind, kann „dynamic_cast“ nicht für die Typkonvertierung verwendet werden. Außerdem kann „dynamic_cast“ im Vergleich zu anderen Casting-Operatoren aufgrund der beteiligten Laufzeittypprüfung relativ langsamer sein.

Mithilfe eines C++-Programms lernen wir, wie der „dynamic_cast“ zur Konvertierung implementiert wird.

#include

Namespace std verwenden;

Klasse Base {

öffentlich:

virtuelle ~Base() {}

};

Klasse Abgeleitete_Klasse : öffentliche Basis {

öffentlich:

void abgeleiteteMethode() {

cout << "Abgeleitete Methode wird aufgerufen!" << endl;}};int main() {Basis*b = neue abgeleitete Klasse;Abgeleitete_Klasse* d = dynamic_cast(b);

wenn (d != nullptr) {

d->abgeleiteteMethode();

} anders {

cout << "Dynamisches Casting ist fehlgeschlagen!" << endl;}b löschen;gebe 0 zurück;}

In diesem Beispiel haben wir eine Basisklasse namens „Base“ und eine abgeleitete Klasse, die als „Derived_Class“ bezeichnet wird. Die abgeleitete Klasse hat die Methode derivedMethod(), die beim Aufruf die Anweisung „Abgeleitete Methode wird aufgerufen!“ ausgibt. Innerhalb der Funktion main() erstellen wir einen Zeiger „b“ vom Typ Base*, der auf ein Objekt der „Derived_Class“ zeigt.

Anschließend wird „b“ mithilfe von „dynamic_cast“ in die Derived_Class* umgewandelt. Da das Objekt, auf das verwiesen wird, vom Typ „Derived_Class“ ist, ist die dynamische Umwandlung erfolgreich. Der Zeiger „d“ ist nicht null, daher können wir die derivedMethod() problemlos darauf aufrufen. Das Programm gibt „Abgeleitete Methode wird aufgerufen!“ aus, was anzeigt, dass die abgeleitete Methode erfolgreich aufgerufen wurde.

Wenn die dynamische Umwandlung fehlschlägt, d. h. das Objekt, auf das verwiesen wird, nicht vom Typ „Derived_Class“ ist, gibt die dynamische Umwandlung einen Nullzeiger zurück. In diesem Fall gibt das Programm stattdessen „Dynamische Umwandlung fehlgeschlagen!“ aus.

Die generierte Ausgabe sieht wie folgt aus:

Abschluss

Dieser Beitrag konzentrierte sich auf die beiden Casting-Typen in C++, nämlich „static_cast“ und „dynamic_cast“. Wir haben Ihnen einen vollständigen Überblick über beide Casting-Typen gegeben. Außerdem wird die Verwendung dieser Typ-Castings näher erläutert. Wir haben die verschiedenen Beispiele für „static_cast“ und „dynamic_cast“ durchgeführt, um die Konzepte besser zu verstehen. Die Ausgaben für die Programme werden ebenfalls angezeigt.

Kommentar verfassen

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert

Nach oben scrollen