vielen dank, naubi

Der static_cast Operator wird eingesetzt um zwischen Ganzzahl-Datentypen und Gleitkomma-Datentypen zu konvertieren.

float f = 3.3;
int n = static_cast<int>(f);

In den spitzen Klammern steht der Zieltyp. Wenn man Zeiger auf Objekte einer Hierarchie umwandeln möchte, sollte man eher dynamic_cast benutzen.

--------------------------------

const_cast

Der const_cast Operator dient dazu, den const oder volatile Modifizierer von einem Datentyp zu entfernen.

const int c = 42;
int c = const_cast<int>(c);

--------------------------------

dynamic_cast

Korrekte Umwandlung eines Zeigers oder einer Referenz auf ein Objekt einer Basisklasse auf ein Objekt einer abgeleiteten Klasse. Dynamic_cast kann nur verwendet werden, wenn die Klasse mindestens eine virtuelle Methode besitzt. Üblicherweise wird der Destruktor virtuell gemacht.

class Base { /*...*/ };
class Derived : public Base { /*...*/ };
Base *bptr1 = new Derived;
Base *bptr2 = new Base;
Derived *dptr1 = dynamic_cast<Derived*>(bptr1); // i. o.
Derived *dptr2 = dynamic_cast<Derived*>(bptr2); // Fehler: bptr2 zeigt auf eine Instanz von Base

class Base { /*...*/ };
class Derived : public Base { /*...*/ };
Derived dobj;
Base bobj;
Base &bref1 = dobj;
Base &bref2 = bobj;
Derived &dref1 = dynamic_cast<Derived&>(bref1); // i. o.
Derived &dref2 = dynamic_cast<Derived&>(bref2); // Fehler: bref2 referenziert eine Instanz von Base

* Diese Art der Umwandlung funktioniert nur, wenn das umzuwandelnde Objekt wirklich eines des Zieltyps ist.
* Für die umgekehrte Richtung passiert die Umwandlung implizit, dynamic_cast wird nicht benötigt.
* Achtung: Schlägt die Umwandlung eines Zeigers fehl, gibt dynamic_cast einen Nullzeiger (0) zurück!
* Achtung: Schlägt die Umwandlung einer Referenz fehl, wirft dynamic_cast die Ausnahme std::bad_cast!

----------------------------------

reinterpret_cast

Gefährlichster und mächtigster Cast, der selten wirklich benötigt wird.

Der reinterpret_cast Operator wird zum einen für die Konvertierung zwischen verschiedenen Zeigertypen und zum anderen für die Konvertierung von Ganzzahlen in Zeiger und umgekehrt eingesetzt.

Mit ihm können u.a. Zeiger in Datentypen (und umgekehrt) „uminterpretiert“ werden.

int i = 25;
float *fp = reinterpret_cast<float*>(i);

In diesem Beispiel zeigt fp auf eine höchstwahrscheinlich undefinierte Float-Variable an der Speicheradresse 25.

float f = 3.3;
int n = static_cast<int>(f);

Schlechtes Beispiel, da hierfür kein Cast nötig ist. Ich würde static_cast eher wie folgt benutzen:

int num = 13;
int denom = 6;
float quotient = static_cast<float>(num) / static_cast<float>(denom);
// wobei ein static_cast reichen würde.

const int c = 42;
int c = const_cast<int>(c);

Ebenfalls schlechtes Beispiel, aus gleichem Grund wie oben. const_cast entfernt CV-Qualifizierer von Zeigern und Referenzen. Kopien brauchen keinen Cast.

const int var = func(); // damit var kein konstanter Ausdruck ist
const_cast<int&>(var) = 7;

Jedoch stellt const_cast in den meisten Fällen einen Designfehler dar und sollte so wenig wie möglich eingesetzt werden.

Auch dynamic_cast ist normalerweise selten notwendig, wenn man Polymorphie mittels virtueller Funktionen löst. Dann weiss jede Klasse selber, was sie zu tun hat, und man braucht keine explizite Fallunterscheidung.