An diversen Stellen in einem Programm werden kommentarlos implizite Typumwandlungen durchgeführt, die meistens erwünscht sind, manchmal auch nicht (wir sehen später, wie man das bei eigenen Typen mit dem Schlüsselwort explicit verhindern kann).

• Ganzzahlige Typen, die kleiner als int sind (z.B. char, short, Bitfelder mit einer Länge kleiner als die int-Länge, enum-Typen) werden automatisch nach int konvertiert oder, wenn sie nicht hineinpassen, nach unsigned int (z.B. unsigned short, wenn int und short gleich groß sind, etc.).

  bool gilt auch als kleiner als int und wird in die int-Werte 0 bzw. 1 ungewandelt.

• Größere ganzzahlige Typen können kleineren ganzzahligen Typen ohne Warnung zugewiesen werden. Dabei gehen eventuell Bits verloren, die zu einer wenig sinnvollen Interpretation führen können:

  Bei

  unsigned int u=-1;

  wird vom Compiler noch gewarnt, bei

  int i=-1; unsigned int u=i;

  nicht mehr, und bei Zweierkomplement-Darstellung hat u hinterher meistens einen der Werte 2¹⁶-1=65535 oder 2³²-1=4294967295.

• Ganzzahlige Typen können nach bool konvertiert werden (und zwar 0 nach false und alle anderen Werte nach true.

• Gleitkommatypen können einander beliebig zugewiesen werden. Die Richtung

  float -> double -> long double

  ist dabei problemlos, während umgekehrt Überläufe und Genauigkeitsverluste auftreten können.

• Wenn man Gleitkommawerte ganzzahligen Objekten zuweist, geschieht dies durch Abschneiden der Nachkommastellen -- der Compiler warnt. Das Verhalten bei zu großen Werten ist nicht vorgeschrieben.

  Bei der umgekehrten Richtung wird nicht gewarnt, es kann bei großen long-Werten, die nach float gewandelt werden, aber Genauigkeitsverluste geben (IEEE-32 hat nur 23 Mantissenstellen).

• Treffen unterschiedliche Typen bei binären arithmetischen Operatoren wie + - * / % < > += *= etc. aufeinander, wird der "kleinere", ungenauere Typ dem anderen angeglichen, bevor die Operation ausgeführt wird. Das Ergebnis hat dann als Ergebnistyp den "größeren" Typ. Das heißt genauer:
  • Ist ein Operand long double, wird der andere nach long double umgewandelt (wenn er es nicht schon selbst ist). Ansonsten wird mit double und float genauso verfahren.

  • Sind dagegen beide Operanden ganzzahlig, wird zunächst nach int gewandelt (s.o.).

  • Ist danach ein Operand unsigned long, wird ggf. der andere dahin konvertiert.

  • Ist sonst ein Operand long und der andere unsigned, wird entweder dieser nach long konvertiert (wenn so je nach Implementation keine Verluste entstehen), oder beide werden "vorsichtshalber" nach unsigned long konvertiert.

  • Ansonsten wird bei Auftreten eines long-Operanden nach long oder sonst bei Auftreten eines unsigned-Operanden nach unsigned gewandelt.

  • Sonst sind schon beide Operanden int und dürfen es auch bleiben...

• Der int-Wert 0 kann Pointern beliebig zugewiesen werden und steht dann für den NULL-Pointer.

• Beliebige Zeigertypen T* bzw. const T* können unbestimmten Zeigertypen void* bzw. const void* zugewiesen werden, aber nicht umgekehrt.

• Array-Typen T[] werden automatisch (meistens als Funktionsargumente) in Pointer-Typen T* konvertiert (Pointer auf das erste Array-Element).

Typumwandlungen, deren Art erst zur Laufzeit bestimmt wird, heißen dynamische Typumwandlungen und sind (für "verwandte" Klassen) mit dem Operator dynamic_cast möglich, der (viel) später besprochen wird.

Hier wollen wir uns nur mit statischen Typumwandlungen beschäftigen, d.h. solchen, die zur Übersetzungszeit festgelegt werden.

Die C-typischen Casts mit () sind in C++ natürlich immer noch erlaubt, es werden aber darüber hinaus speziellere Operatoren mit neuen Schlüsselwörtern zur Verfügung gestellt.

4.1: Lvalues

Startseite

5.1: Anweisungen