unsigned x = 65535;    // 0xFFFF grösster Wert
unsigned y = 65535;
long unsigned = z;
z = x * y;             // kein Problem, Ergebnis passt
                       // da < 0xFFFFFFFF

Wie schnell nachgerechnet werden kann, ergibt diese Multiplikation den Wert 4.294.836.225 was hexadezimal dem Wert FFFE0001h entspricht. Er passt also in eine Variable vom Typ long unsigned.

Probleme ..

.. entstehen, wenn ein Integer (int) einem Character (char) zugeordnet werden soll, oder eine Fliesskommazahl (float) einem Integer (int). Der Compiler würde sofort erkennen, dass hier ein mögliches Fehlerpotential enthalten ist. Er weiss, dass es unmöglich ist, in nur einem Byte die Werte von zwei Bytes unterzubringen oder die Nachkommastellen einer Fliesskommazahl in einer Ganzzahl aufzuheben. Er würde mit einer Meldung reagieren.

Nun ist es durchaus möglich, dass ein Programmierer eine solche Zuordnung wünscht. Weiss er beispielsweise, dass ein Wert, der in einer int-Variablen aufgehoben ist, nie über den grössten char-Wert hinauswachsen wird und möchte ihn nun in einen char-Speicher übertragen, dann stören ihn die Warnungen des Compilers.

Die Frage ist, wie kann der Programmierer dem Compiler beibringen, dass er diese Zuweisung will? ...

Ein Programmierer kann seinen Willen gegen den des Compilers durchsetzen, wenn er die Typenwandlung explizit (ausdrücklich) anweist. Dies tut er durch einen Formalismus der in der Sprache C als explizite Typwandlung bezeichnet wird ..

Beispiel 1:

unsigned x = 0x00FF;   // maximaler Wert für char 
char y;
y = (char) x;          // Inhalt unsigned nach char

Hier wird durch die explitite Typenwandlung (char) dem Compiler mitgeteilt, dass sich der Programmierer über die Gefahr bewusst ist, dass bei dieser Zuweisung, in der char-Variablen, alle Ziffern der unsigned Variablen verloren gehen, die über den Wert 0xFF hinausreichen.

Explizite Typenwandlung ..

.. muss immer dann angewendet werden, wenn bei einer Zuweisung die Gefahr eines Genauigkeitsverlustes ansteht, der Programmierer die Zuweisung aber dennoch durchführen will.

Beispiel 2:

Der Inhalt eines Speichers mit einer doppeltgenauen Fliesskommazahl (kleiner oder gleich 65535) soll einer Ganzzahl vom Typ unsigned zugeordnet werden. Hierbei werden die Nachkommastellen verloren gehen. Da der Programmierer aus der Fliesskommazahl aber einen Punkt auf dem Bildschirm festlegen will stört ihn das nicht. Er schreibt ..

double fliesskommazahl = 3456,1243;
unsigned ganzzahl = 0;
ganzzahl = (unsigned) fliesskommazahl;

Das Ergebnis in ganzzahl ist der Wert 3456. Die Nachkommastellen wurden ohne Rundung abgeschnitten.

Das Verfahren der expliziten Typenwandlung kann von jedem Variablentyp zu jedem anderen angewendet werden. Wenn beispielsweise ein Programmierer weiss, dass sich eine lange Ganzzahl als Adresse in dem Speicher des Rechners eignet, dann kann er die lange Ganzzahl zu einem Zeiger umwandeln. In diesem Fall lautet die explizite Typenwandlung ..

Beispiel 3:

long unsigned zahl = 0x12345678L;
char far* zeiger = 0L; 
zeiger = (char far*) zahl;       // Inhalt zahl wird
                                 // Zeiger auf char

Eine Benutzung des langen Integers zahl als Zeiger wäre auf den Widerwillen des Compilers gestossen. Die Zeile ..

char c;

c = *zahl; // geht nicht

.. hätte eine Fehlermeldung erzeugt. Hingegen wird nach der Typenwandlung von zahl in einen Zeiger ohne weiteres der Inhalt der Speicherzelle nach c übertragen, auf den der Inhalt von zahl zeigt.

c = (char far*) *zahl; // gehen beide

c = *zeiger;