7.2 Explizite Datentypumwandlung mit dem »cast«–Operator

Da die implizite Datentypumwandlung häufig zu Fehlern bzw. unerwünschten Ergebnissen führen kann, gibt es noch die explizite Datentypumwandlung, womit der Variablentyp mit cast-Operator durchgeführtwerden kann. Dieses explizite Casten des Datentyps wird quasi entgegen der Compiler-Regeln erzwungen. Der cast-Operator besteht aus einem eingeschlossenen gültigen Datentyp.

Die Syntax einer expliziten Typumwandlung sieht folgendermaßen aus:

(typ) ausdruck;

Dabei wird zuerst der ausdruck ausgewertet, und anschließend wird dieser Wert in einen Datentyp typ umgewandelt.

Das folgende Beispiel zeigt das implizite und das explizite Type-Casting im Vergleich:

/* casting.c */
#include <stdio.h>

int main(void) {
   int x = 5, y = 2;
   float z;
   // Implizite Datentypumwandlung
   z = x / y;
   printf("%f\n", z);             // = 2.000000
   // Explizite Datentypumwandlung
   z = (float) x / (float) y;
   printf("%f\n", z);             // = 2.500000
   return 0;
}

Die erste Berechnung

z = x / y;

gibt das Ergebnis »2.000000« aus. Das ist leicht nachvollziehbar, denn es werden zwei int-Werte dividiert. int-Werte können keinen Wert nach dem Komma darstellen. Dass hier das Ergebnis dennoch vom Typ float ist, verdanken Sie dem impliziten Type-Casting des Compilers.

Die Berechnung

z = (float) x / (float) y;

konvertiert die beiden Datentypen int explizit in float-Typen. Deshalb erhalten Sie als Ergebnis »2.500000« zurück.

Wichtig ist dabei, dass x und y im Programm weiterhin vom Datentyp int sind. Das »Casten« des Datentyps ist nur während dieser einen Ausführung gültig.

Es hätte auch gereicht, nur einen dieser beiden Typen zu casten, denn wenn Sie zwei verschiedene Variablen miteinander durch Operatoren verknüpfen, bekommen Sie das Ergebnis des genaueren Typs dieser beiden Variablen zurück:

z = (float) x / y; /* Ergebnis = 2.50000 */

Aber Achtung, falls Sie vorhaben, Gleitpunktzahlen in Ganzzahlen umzuwandeln – etwa folgendermaßen:

long x;
float z = 5.5;
x = (long) z;

Hier wird der Wert nach dem Komma abgeschnitten. Falls Sie einen Wert umwandeln wollen, der größer als seine Zielgruppe ist, liegt ein undefiniertes Verhalten vor. Wird z. B. ein float-Wert in einen short-Wert konvertiert, könnte das zu Problemen führen, denn der float-Wert hat eine Größe von vier Bytes und der short-Wert eine von zwei Bytes. Mit niedrigeren Werten mag dies zufällig funktionieren:

short x;
float z = 25.0;
x = (short) z;

Sollte der Wert von float z. B. »1000000.0« betragen, wird dies nicht mehr gelingen, denn der Wert »1000000« ist nicht mehr mit 16 Bit (= 2 Bytes) darstellbar. Das Gleiche gilt auch für Casts von double nach float oder von long double nach double.

Ihre Meinung

Wie hat Ihnen das Openbook gefallen? Wir freuen uns immer über Ihre Rückmeldung. Schreiben Sie uns gerne Ihr Feedback als E-Mail an kommunikation@rheinwerk-verlag.de.