Explizite Typumwandlung

Typumwandlung (engl. type conversion oder cast) bezeichnet in der Informatik die Umwandlung des Wertes eines Datentyps in einen Wert eines anderen Datentyps.

Beispielsweise kann es sein, dass man eine Zahl als Zeichenkette darstellen möchte. Es muss dann eine Umwandlung der für die Darstellung der Zahl verwendeten Daten in die für die Darstellung einer Zeichenkette notwendigen Daten vorgenommen werden:

string s;    // Variable s kann Zeichenkette aufnehmen
int i = 42;  // Variable i nimmt ganze Zahl 42 auf (z. B. Daten "002A" (hex) auf 16-bit Rechner)
s = i;       // s soll Wert von i annehmen --Typkonflikt-- hier muss Konvertierung erfolgen!
             // z. B. in "343200" (ASCII Code für Zeichen 4 und 2, sowie C-String Terminator)

Oft kann der eine Datentyp den gesamten Wertebereich des anderen Datentyp aufnehmen, so dass man je nach Vergrößerung oder Verkleinerung der Wertemenge des Datentyps von Typerweiterung (engl. type promotion) oder Typeinschränkung (engl. type demotion) spricht.

Es gibt explizite und implizite Typumwandlungen.

Explizite Typumwandlungen

Eine explizite Typumwandlung wird im Programmcode angegeben. Eine explizite Typumwandlung bezeichnet man auch als type cast (aus dem Englischen).

Der folgende Code-Schnipsel zeigt eine explizite Typumwandlung in Java:

int  i = 100;
byte b = (byte) i;

Dabei handelte es sich bei der Angabe (byte) um die explizite Typumwandlungsoperation.

Je nach Typisierung der verwendeten Programmiersprache kann das Fehlen der expliziten Angabe der Typumwandlung einen Fehler während der Kompilierung oder während der Laufzeit zur Folge haben.

Eine Variante expliziter Typumwandlung ist die Verwendung eigens dafür geschriebener Funktionen:

int  i = 100;
byte b = int2byte( i );

Funktionen analog zu int2byte() werden insbesondere in Programmiersprachen verwendet, die keine Operatoren dafür besitzen.

Implizite Typumwandlungen

Im Unterschied zu expliziten Typumwandlungen erscheinen implizite Typumwandlungen nicht im Quelltext. Sie werden entweder nach durch die jeweilige Programmiersprache vorgegebenen Vorschriften, oder gemäß einem vom Programmierer an einer anderen Stelle im Quelltext festgelegten Verfahren durchgeführt.

Beispiel:

byte b = 100;
int  i = b;

Dabei findet in der zweiten Zeile eine implizite Typumwandlung vom Typ byte in den Typ int statt. In diesem Fall ist die implizite Typumwandlung durch die Programmiersprache festgelegt.

Implizite Typumwandlung findet oftmals nur dann statt, wenn sie ohne Informationsverlust erfolgen kann, also wenn der Zieldatentyp einen gleichen oder größeren Wertebereich hat als der Ausgangsdatentyp. So erfolgt bei Bedarf zwar eine implizite Typumwandlung von byte (8 bit) nach int (16 bit), nicht aber umgekehrt.

Beispiel aus Java

Das folgende in der Programmiersprache Java geschriebene Beispiel verdeutlicht, wie implizite Typumwandlungen zu Fehlern in Programmen führen können, die schwer zu entdecken sind.

int z = 18;
float y = z / 4;                // explizit: float y = (float) ( z / 4 )
System.out.print(y);

Dieser Java-Code liefert, gegen die Intuition, nicht „4.5“ (4,5) als Ergebnis, sondern „4.0“ (4,0). Grund hierfür ist der Ausdruck z/4, der als ganzzahlige Division interpretiert wird, weil beide Argumente („z“ und „4“) vom Typ Integer sind. 18/4 = 4 Rest 2, der ganzzahlige Divisionsoperator „/“liefert somit 4. Die ganze Zahl 4 wird dann implizit in den Gleitkommawert („float“) „4.0“ umgewandelt, d. h. vor der Division findet keine Umwandlung statt. Als Kommentar ist die implizite Typumwandlung, die der Java-Compiler einfügt, explizit aufgeführt. Es gibt mehrere Möglichkeiten, den Code so zu ändern, dass er das gewünschte Ergebnis liefert. Falls einer der Parameter bei einer Division den Type „float“ hat, und der andere den Type „int“, so wird der ganzzahlige Wert implizit in eine Gleitkommazahl umgewandelt, und die Division als Gleitkommadivision durchgeführt.

int z = 18;
float y = z / 4.0f;
System.out.print(y);

Hier wird somit die Variable „z“ implizit in einen Float konvertiert, und zwar vor der Division. Ein andere Lösung ist es, die Variable „z“ explizit in einen Gleitkommawert umzuwandeln:

int z = 18;
float y =  (float) z / 4; 
System.out.print(y);

Bei dieser Version wird die ganze Zahl 4 implizit in eine Gleitkommazahl umgewandelt, da die Variable „z“ explizit in eine Gleitkommazahl umgewandelt wird, denn die Typumwandlung bindet stärker als der Bruchstrich (Operatorrangfolge). Die einzige Version ohne implizite Umwandlungen erfordert es, dass beide Parameter der Division Gleitkommazahlen sind, und lautet deshalb:

int z = 18;
float y =  (float) z / 4.0f;
System.out.print(y);

Siehe auch

Konvertierung (Informatik)