![Page 1: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/1.jpg)
Datentyp-umwandlung
![Page 2: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/2.jpg)
Literale sind:Bezeichner mit einem festen Wert wie z.B:
![Page 3: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/3.jpg)
237 (dezimale Angabe)034 (oktale Angabe)0x51f (hexadezimale
Angabe)3.14 (Fließkommazahl)
'x' (Zeichen)"abc" (Zeichenkette)
![Page 4: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/4.jpg)
Literale sind dem Compiler bekannt und müssen nicht - wie Variable - deklariert (angemeldet) werden.
![Page 5: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/5.jpg)
Welchen Datentyp hat ein Literal ?
![Page 6: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/6.jpg)
Welchen Datentyp hat z.B. eine Ganzzahl wie
4 000 000 000 ?Kann diese z.B. den
Datentyp int annehmen ?
![Page 7: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/7.jpg)
Dazu muss man sich fragen :1) Wie viele Bytes werden für int (in MS VC++) reserviert ?2) Welchen Zahlenbereich umfasst der Datentyp int (in MS VC++) ?
![Page 8: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/8.jpg)
... und stellt dann fest:4 Bytes reserviert MS VC++ für int. Man kann also 232 = 4294967296 Zahlen abspeichern. Da int auch negative Zahlen umfasst, geht der Zahlenbereich von: -2147483648...2147483647
![Page 9: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/9.jpg)
Kann also die Ganzzahl 4 000 000 000 mit dem Datentyp int abgespeichert werden ?
![Page 10: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/10.jpg)
Nein, denn int umfasst nur den Zahlenbereich von: -2147483648...2147483647
![Page 11: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/11.jpg)
Also wird Ganzzahlen zwischen: -2147483648...2147483647der Datentyp int zugeordnet und Ganzzahlen zwischen 2147483648...4294967295der Datentyp unsigned int zugeordnet
![Page 12: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/12.jpg)
Ganzzahlen werden also - abhängig vom Wert - folgende Datentypen zugeordnet:
![Page 13: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/13.jpg)
dezimale Ganzzahl:int
unsigned int
long
z.B: 1234
z.B: 4 000 000 000
unsigned long
Siehe Hilfe in MS VC++
![Page 14: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/14.jpg)
Einer Fließkommazahl wird der folgende Datentyp
zugeordnet:
double
![Page 15: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/15.jpg)
Beispiel:
...int i,j;double d;i=2*3;d=1.9*2.1;j=4/5;...
Welchen Datentyp hat 2*3, 1.9*2.1 und 4/5 ?
![Page 16: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/16.jpg)
Merke:
![Page 17: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/17.jpg)
int + int = intint - int = intint * int = int
int / int = int
float + float = floatfloat - float = floatfloat * float = float float / float = float
double + double = doubledouble - double = doubledouble * double = double double / double = double
Weil z.B. 3/10 keine ganze Zahl (integer)
ergibt.
Welche der Regeln widerspricht unserer Alltagsmathematik?
![Page 18: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/18.jpg)
Welche Datentypen haben also die folgenden Ergebnisse:
double
1.9 * 2.1
double
double
Ergebnis: 3.99
double * double = double
![Page 19: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/19.jpg)
double
3.0 / 2.0
double
double
Ergebnis: 1.5
double /double = double
![Page 20: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/20.jpg)
integer
2 * 3
integer
integer
Ergebnis: 6
integer * integer = integer
![Page 21: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/21.jpg)
integer
8 / 5
integer
integer
Ergebnis: Der Nachkommateil von 8/5 = 1.6 (also 0.6) wird entfernt. Also ist das Ergebnis: 1
integer / integer = integer
![Page 22: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/22.jpg)
Problem:Verschiedene Datentypen in
einem Ausdruck
Welchen Datentyp hat der gesamte Ausdruck ?
![Page 23: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/23.jpg)
Beispiel:
![Page 24: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/24.jpg)
...int i;double d;double erg;i=2;d=3.14;erg=i*d;...
Welchen Datentyp hat i*d ?
![Page 25: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/25.jpg)
Antwort:Gemischte Datentypen
werden nicht akzeptiert !!!
Deshalb muss vorher eine Datentyp-Umwandlung
gemacht werden !!!
![Page 26: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/26.jpg)
Dazu gibt es zwei Möglichkeiten:
![Page 27: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/27.jpg)
Implizite Typumwandlung (macht der Compiler selbst, ohne Zutun des Programmierers)
Explizite Typumwandlungmit dem cast-Operator (muss der Programmierer machen)
und
![Page 28: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/28.jpg)
Implizite Typumwandlung:wandelt alle "kleineren" Datentypen in die "grösseren" um.
![Page 29: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/29.jpg)
Tabelle Typumwandlung:
![Page 30: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/30.jpg)
long doubledoublefloatunsigned longlongunsigned intintchar signed
charunsigned
charshort unsigned
short
grös
ser
Diese Datentypen werden direkt in integer umgewandelt:
![Page 31: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/31.jpg)
... char c1 = 64; char c2 = 64; int i = c1 * c2; ...
Welcher Wert wird in i gespeichert ? Was geschieht
im Einzelnen ?
Laut der "Tabelle Typumwandlung" wird der Wert von c1 und c2 sofort in int umgewandelt, nicht erst das Ergebnis c1*c2
Der Wert von c1 * c2, also 4096 wird dann in i gespeichert.
![Page 32: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/32.jpg)
Beispiel:
![Page 33: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/33.jpg)
...int i;double d;double erg;i=2;d=3.14;erg=i*d;...
Welchen Datentyp hat i*d ?
//double: erg=6.28
wird umgewandelt in double, also: 2.0 double,
also: 3.14
double * double = double
![Page 34: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/34.jpg)
Explizite Typumwandlung(mit cast-Operator):
Wandelt mit dem cast-Operator ( ) den Datentyp um.
![Page 35: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/35.jpg)
Beispiel:
![Page 36: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/36.jpg)
...int i;double d;double erg;i=2;d=3.14;erg=d*(double)i;...
double, also: 2.0
double, also 3.14
integer, also: 2
double * double = double
![Page 37: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/37.jpg)
Beispiel:
![Page 38: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/38.jpg)
...int i;double d;int erg ;i=2;d=3.14;erg=i*(int)d;...
Warum gibt es ein Problem ?Es entsteht ein Datenverlust durch (int) d
double, also: 3.14
integer, also: 3
![Page 39: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/39.jpg)
Bei einem möglichen Datenverlust bringt der MS VC++ Compiler eine
Warnung, keine Fehlermeldung.
![Page 40: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/40.jpg)
Der Compiler prüft dabei nicht nach, ob es tatsächlich einen
Datenverlust gibt, sondern nur, ob ein "größerer Datentyp" in einem "kleineren Datentyp"
abgespeichert werden soll und deshalb der dafür vorgesehene Speicherplatz nicht ausreicht.
![Page 41: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/41.jpg)
ACHTUNG:Es ist nicht normiert, wann der Compiler eine Warnung
bringen muss.
![Page 42: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/42.jpg)
Problem:
Bei der Datentypumwandlung eines größeren Datentyps in einen kleineren Datentyp kann (muß aber nicht) ein Informationsverlust entstehen.
![Page 43: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/43.jpg)
Konkretes Beispiel für einen Informationsverlust
![Page 44: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/44.jpg)
int main(){ int i; char z; i = 321; z = (char) i; printf("z=%c",z); }
aus wieviel Bytes besteht i ?
4 Bytes
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 1
Wie sieht die Dualdarstellung von
i aus ?
welche Bytes werden abgeschnitten ?
die Höherwertigen
aus wieviel Bytes besteht z ?
1 Byte
![Page 45: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/45.jpg)
int main(){ int i; char z; i = 321; z = (char) i; printf("z=%c",z); }
0 1 0 0 0 0 0 1
Welches Zeichen wird ausgegeben ? (siehe ASCII-Tabelle)
A01000001
entspricht dezimal 65
![Page 46: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/46.jpg)
int main(){ int i; char z; i = 321; z = i; printf("z=%c",z); }
Was ist hier anders im Vergleich zum letzten Programm ?
Der explizite cast-Operator (char) fehlt.
Der Wert von i, nämlich 321 ist zu groß, als dass er in der Variable z
gespeichert werden kann.
Deshalb wird i implizit in den Datentyp char umgewandelt (Compiler bringt Warnung).
Allgemein gilt:Soll bei einer Zuweisung ein größerer Wert in einer Variablen
gespeichert werden, als diese aufnehmen kann, so wird vorher eine implizite Typumwandlung gemacht.
![Page 47: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/47.jpg)
int main(){ double d; int i=2; d=i; return 0;}
Was ist hier anders im Vergleich zum letzten Programm ?
Der Wert von i soll in einem "grösseren" Datentyp abgespeichert werden.
Deshalb wird i implizit in den grösseren Datentyp double umgewandelt.
Allgemein gilt:Soll bei einer Zuweisung ein kleinerer Wert in einer Variablen eines
"grösseren" Datentyps gespeichert werden, so wird vorher eine implizite Typumwandlung in den grösseren Datentyp gemacht.
![Page 48: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/48.jpg)
Noch ein Beispiel:
![Page 49: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/49.jpg)
int main(){ float f; f = 2.123456789012345;
return 0;}
Warnung: double ---> floatErgebnis: f1 = 2.12346
doublefloat
Es findet also ein tatsächlicher Datenverlust statt, weil double mehr Nachkommastellen speichert als float.
![Page 50: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/50.jpg)
Grosses Beispiel:
![Page 51: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/51.jpg)
int main(){ float f1, f2; double d1, d2; int i1, i2; f1 = 2.3; i1 = 4; i2 = (float)f1; d1 = 3.14; f1 = 6-1/20*f1; f2 = 6-f1/20; // weiter ...
![Page 52: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/52.jpg)
f2 = 6-((float)1/(float)20)*f1; f2 = 6-(1/(float)20)*f1; f2 = 6-(1/20)*f1; f2 = 6-(1.0/20.0)*f1; f2 = 6-0.05*f1; f2 = 0.05*f1; d2 = 6-(1.0/20.0)*f1; d2 = 6-0.05*f1; d2 = 0.05*f1; d2 = 3/5; d2 = 3.0/5.0; }
![Page 53: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/53.jpg)
d2 = i1 * 2.718;}
![Page 54: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/54.jpg)
f1 = 2.3;
doublefloat
Warnung: double ---> floatErgebnis: f1 = 2.3
![Page 55: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/55.jpg)
i1 = 4;
intint
okay:Ergebnis: i1 = 4
![Page 56: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/56.jpg)
i2 = (float)f1;
float
int
Warnung: float ---> inti2 = 2
cast
float
![Page 57: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/57.jpg)
d1 = 3.14;
doubledouble
okay:Ergebnis: d1 = 3.14
![Page 58: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/58.jpg)
f1 = 6 – 1 / 20 * f1;
implizit:(float)0
okay:Ergebnis: f1 = 6
float (konkret 2.3)
intint
implizit:(float)6
int / int = int also:
1 / 20 = 0
float
int
float
float
Punkt vor Strich
![Page 59: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/59.jpg)
f2 = 6 – f1 / 20;
okay:Ergebnis: f2 = 5.7
float, konkret 6 int
implizit:(float)20
float / int deshalb:
float / (float)int = float, also: 6.0 / 20.0 = 0.3
intfloat
int - floatdeshalb:
(float)int – float = float, also: 6.0 – 0.3 = 5.7
implizit:(float)6
![Page 60: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/60.jpg)
f2 = 6-((float)1/(float)20)*f1;
6.0
float / float = float also:
1.0 / 20.0 = 0.05
float
float * float = float also:
0.05 * 6.0 = 0.3
int
implizit:(float)6
float - float = float also:
6.0 – 0.3 = 5.7
float cast cast
okay:Ergebnis: f2 = 5.7
![Page 61: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/61.jpg)
f2 = 6-(1/(float)20)*f1;
6.0
int / floatdeshalb:
(float)int / float = float
float
float * float = float also:
0.05 * 6.0 = 0.3
int
implizit:(float)6
float - float = float also:
6.0 – 0.3 = 5.7
float cast
okay:Ergebnis: f2 = 5.7
![Page 62: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/62.jpg)
f2 = 6-(1/20)*f1;
6.0
int / int = int, also: 1 / 20 = 0
float - float = float also:
6.0 - 0.0 = 6.0
int
float * float = float also:
0.0 * 6.0 = 0.0
float
okay:Ergebnis: f2 = 6.0
int float
implizit:(float)0
int
implizit:(float)6
![Page 63: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/63.jpg)
f2 = 6-(1.0/20.0)*f1;
6.0
double / double = double, also:
1.0 / 20.0 = 0.05
double - double = double also:
6.0 - 0.3 = 5.7
double * double = double also: 0.05 * 6.0 = 0.3
float
Warnung: double --->float Ergebnis: f2 = 5.7
int float
implizit:(double)6
double double
implizit:(double)6
![Page 64: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/64.jpg)
f2 = 6 - 0.05 * f1;
6.0
double * floatdeshalb:
double * (double)float = double
double - double = double also:
6.0 - 0.3 = 5.7
double * double = double also: 0.05 * 6.0 = 0.3
float
Warnung: double --->float Ergebnis: f2 = 5.7
int float
implizit:(double)6
implizit:(double)6
double
![Page 65: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/65.jpg)
f2 = 0.05*f1;
6.0
double * floatdeshalb:
double * (double)float = double, also:0.05 * 6.0 = 0.3
float
Warnung: double --->float Ergebnis: f2 = 0.3
double
implizit:(double)6
float
![Page 66: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/66.jpg)
d2 = 6-(1.0/20.0)*f1;
6.0
double / double = double, also:
1.0 / 20.0 = 0.05
double - double = double also:
6.0 - 0.3 = 5.7
double * double = double also: 0.05 * 6.0 = 0.3
double
okay:Ergebnis: d2 = 5.7
int float
implizit:(double)6
double double
implizit:(double)6
![Page 67: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/67.jpg)
d2 = 6 - 0.05 * f1;
6.0
double * floatdeshalb:
double * (double)float = double
double - double = double also:
6.0 - 0.3 = 5.7
double * double = double also: 0.05 * 6.0 = 0.3
double
okay: Ergebnis: d2 = 5.7
int float
implizit:(double)6
implizit:(double)6
double
![Page 68: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/68.jpg)
d2 = 0.05 * f1;
6.0
double * floatdeshalb:
double * (double)float = double, also:0.05 * 6.0 = 0.3
double
okay: Ergebnis: d2 = 0.3
double
implizit:(double)6
float
![Page 69: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/69.jpg)
d2 = 3 / 5;
int / int = int, also:
3 / 5 = 0
double
okay: Ergebnis: d2 = 0.0
int int
![Page 70: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/70.jpg)
d2 = 3.0 / 5.0;
double / double = double, also:
3.0 / 5.0 = 0.6
double
okay: Ergebnis: d2 = 0.6
double double
![Page 71: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/71.jpg)
d2 = i1 * 2.718;
double
okay: Ergebnis: d2 = 10.872
int double4
int * doubledeshalb:
(double) int * double = double, also:
4.0 * 2.718 = 10.872
![Page 72: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/72.jpg)
Zusammenfassung
![Page 73: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/73.jpg)
int main(){ float f1, f2; double d1, d2; int i1, i2; f1 = 2.3; i1 = 4; i2 = (float)f1; d1 = 3.14; f1 = 6-1/20*f1; f2 = 6-f1/20; // weiter ...
//Warnung: double ---> float
//Warnung: float ---> int
// Ergebnis: f1 = 6 // Ergebnis: f2 = 5,7
![Page 74: Datentyp- umwandlung. Literale sind: Bezeichner mit einem festen Wert wie z.B:](https://reader036.vdokument.com/reader036/viewer/2022062512/55204d6549795902118bac79/html5/thumbnails/74.jpg)
f2 = 6-((float)1/(float)20)*f1; f2 = 6-(1/20)*f1; f2 = 6-(1.0/20.0)*f1; f2 = 6-0.05*f1; f2 = 0.05*f1; d2 = 6-(1.0/20.0)*f1; d2 = 6-0.05*f1; d2 = 0.05*f1; d2 = 3/5; d2 = 3.0/5.0; d2 = i1 * 2.718;
// Warnung: double ---> float
// Ergebnis: d2=0.6
// Ergebnis: d2 = 0
//Warnung: double ---> float
// Warnung: double ---> float
// Ergebnis: f2 = 6
// Ergebnis: d2 =5,7
// Ergebnis: d2 =5,7
// Ergebnis: d2 =0,3
// Ergebnis: d2 =10,872