Revision history for ProzProg3DatentypenOperatoren
Additions:
CategoryProzeduraleProgrammierung
Deletions:
Additions:
CategoryDelete
Deletions:
Additions:
a/b; ""//Ergebnis 0 (ohne Konvertierung)""
(double)a/b; ""//Ergebnis 0.25""
double(a)/b; ""//Ergebnis 0.25""
(double)a/b; ""//Ergebnis 0.25""
double(a)/b; ""//Ergebnis 0.25""
Deletions:
(double)a/b; //Ergebnis 0.25
double(a)/b; //Ergebnis 0.25
Additions:
Konvertierung vom größeren zum kleineren Typen kann zu Informationsverlusten führen:
1) Bei der Umwandlung eines ganzzahligen Typs in kleineren werden die höherwertigen Bytes abgeschnitten,
z.B.: short a=262151; // 7
2) Bei der Umwandlung eines Gleitkomma-Typs in einen ganzzahligen Typ wird gebrochener Teil abgeschnitten,
z.B.: short a=2.9; // 2
Wenn der Ganzteil zu groß ist, ist das Ergebnis unbestimmt,
z.B.: short a= 32769.5; // -32767
3) Bei der Umwandlung eines Gleitkomma-Typs in einen kleineren Gleitkomma-Typ wird das Ergebnis (implementierungsabhängig) abgeschnitten oder gerundet, wenn der Wertebereich des neuen Typs überschritten wird,
z.B.: float a= 3.4E+39; //INF
""⇒"" Demo 8. Konvertierung
===Implizite Typkonvertierung===
Eine Typkonvertierung wird als implizite bezeichnet, wenn sie vom Compiler automatisch vorgenommen wird.
1. Konvertierung in Ausdrücken Traditionelle arithmetische Operatoren (+ - * /) haben vier folgende Signaturen:
Typ den Operanden
Ergebnis-Typ
int + int
int
int + double
double
double + int
double
double + double
double
Bei anderen Typen versucht der Compiler implizit von unten nach oben zu konvertieren.
2. Konvertierung bei der Zuweisung Die Konvertierungsrichtung wird vom Programmierer bestimmt.
===Cast -Operator===
Eine explizite Typkonvertierung wird mittels des unären Cast-Operators ausgeführt.
Syntax in C: (typname) Operand
Zusätzlich in C++: typname (Operand)
Explizite Konvertierungen können in Ausdrücken und bei der Zuweisung vorgenommen werden, z.B.:
int a = 1, b=4;
a/b; //Ergebnis 0 (ohne Konvertierung)
(double)a/b; //Ergebnis 0.25
double(a)/b; //Ergebnis 0.25
Vorteile:
1) Programmierer dokumentiert seinen Willen.
2) Potentielle Fehlerquellen können gezielt lokalisiert werden.
3) Lesbarkeit wird verbessert.
1) Bei der Umwandlung eines ganzzahligen Typs in kleineren werden die höherwertigen Bytes abgeschnitten,
z.B.: short a=262151; // 7
2) Bei der Umwandlung eines Gleitkomma-Typs in einen ganzzahligen Typ wird gebrochener Teil abgeschnitten,
z.B.: short a=2.9; // 2
Wenn der Ganzteil zu groß ist, ist das Ergebnis unbestimmt,
z.B.: short a= 32769.5; // -32767
3) Bei der Umwandlung eines Gleitkomma-Typs in einen kleineren Gleitkomma-Typ wird das Ergebnis (implementierungsabhängig) abgeschnitten oder gerundet, wenn der Wertebereich des neuen Typs überschritten wird,
z.B.: float a= 3.4E+39; //INF
""⇒"" Demo 8. Konvertierung
===Implizite Typkonvertierung===
Eine Typkonvertierung wird als implizite bezeichnet, wenn sie vom Compiler automatisch vorgenommen wird.
1. Konvertierung in Ausdrücken Traditionelle arithmetische Operatoren (+ - * /) haben vier folgende Signaturen:
Typ den Operanden
Ergebnis-Typ
int + int
int
int + double
double
double + int
double
double + double
double
Bei anderen Typen versucht der Compiler implizit von unten nach oben zu konvertieren.
2. Konvertierung bei der Zuweisung Die Konvertierungsrichtung wird vom Programmierer bestimmt.
===Cast -Operator===
Eine explizite Typkonvertierung wird mittels des unären Cast-Operators ausgeführt.
Syntax in C: (typname) Operand
Zusätzlich in C++: typname (Operand)
Explizite Konvertierungen können in Ausdrücken und bei der Zuweisung vorgenommen werden, z.B.:
int a = 1, b=4;
a/b; //Ergebnis 0 (ohne Konvertierung)
(double)a/b; //Ergebnis 0.25
double(a)/b; //Ergebnis 0.25
Vorteile:
1) Programmierer dokumentiert seinen Willen.
2) Potentielle Fehlerquellen können gezielt lokalisiert werden.
3) Lesbarkeit wird verbessert.
Additions:
Mit dem sizeof-Operator kann man den benötigten Speicherplatz eines Datentyps abfragen, z.B.: ""cout<< sizeof (int); ""
""<table class="center" border="1" style="text-align:center;" cellpadding="0" cellspacing="0"><tr><td>
long double<br/>
^ <br/>
double <br/>
^ <br/>
float <br/>
^ <br/>
long <br/>
^ <br/>
int <br/>
^ <br/>
short <br/>
^ <br/>
""<table class="center" border="1" style="text-align:center;" cellpadding="0" cellspacing="0"><tr><td>
long double<br/>
^ <br/>
double <br/>
^ <br/>
float <br/>
^ <br/>
long <br/>
^ <br/>
int <br/>
^ <br/>
short <br/>
^ <br/>
Deletions:
""<table class="center" border="1" style="text-align:center;"><tr><td>
long double
^
double
^
float
^
long
^
int
^
short
^
Additions:
===Typhierarchie (ohne unsigned) ===
""<table class="center" border="1" style="text-align:center;"><tr><td>
</td></tr></table>""
""<table class="center" border="1" style="text-align:center;"><tr><td>
</td></tr></table>""
Deletions:
"<table class="center" border="1" style="text-align:center;"><tr><td>
</td></tr></table>
Additions:
Konvertierung ohne Informationsverlust läuft automatisch von kleineren (niedrigegen) zu größeren (höheren) Typen ab. Diese Regel kann als eine Typhierarchie dargestellt werden. Bei der Konvertierung von unten nach oben muss der Wert erweitert werden, z.B.:
double a=1;
Hier wird der int-Wert (4 Byte) zum double-Wert (8 Byte) konvertiert.
Mit dem sizeof-Operator kann man den benötigten Speicherplatz eines Datentyps abfragen, z.B.: cout<< sizeof (int);
""⇒"" Demo 7. sizeof
Typhierarchie (ohne unsigned)
"<table class="center" border="1" style="text-align:center;"><tr><td>
long double
^
double
^
float
^
long
^
int
^
short
^
char
</td></tr></table>
double a=1;
Hier wird der int-Wert (4 Byte) zum double-Wert (8 Byte) konvertiert.
Mit dem sizeof-Operator kann man den benötigten Speicherplatz eines Datentyps abfragen, z.B.: cout<< sizeof (int);
""⇒"" Demo 7. sizeof
Typhierarchie (ohne unsigned)
"<table class="center" border="1" style="text-align:center;"><tr><td>
long double
^
double
^
float
^
long
^
int
^
short
^
char
</td></tr></table>
Additions:
(x > 0)? x: -x; // Absolutwert von x
(n == 0)? 1: z/n; // Quotient z/n
// oder 1, falls der Nenner 0 ist
a>b ? a : b; // Maximum zweier Zahlen
===Assoziativität===
In einem Ausdruck können Operatoren gleicher Prioritätsstufe vorkommen, z.B.: 5+4-3 oder 5+4+3
Dabei wird die Ausführungsreihenfolge durch die Assoziativität der Operatoren bestimmt:
1. Linksassoziativität (in Links-Rechts-Richtung)
2. Rechtsassoziativität (in Rechts-Links-Richtung)
Die Operatoren +, -, *, / werden von links nach rechts abgearbeitet. Die Assoziativität der Operatoren wird in der Operatoren-Tabelle angegeben.
Man sollte in komplexeren Ausdrücken, in denen arithmetische, relationale und logische Operatoren gemischt vorkommen, lieber Klammern setzen, um jedes Mißverständnis auszuschließen.
===Auswertung der Operanden ===
Ein Operand ist ein Literal oder ein Variablenname oder ein Konstantenname oder ein Teilausdruck in runden
Klammern.
Beispiel: int x=0;
int sum = (x=3) + (++x);
Die Variable sum kann hier den Wert 4 oder den wert 7 annehmen, abhängig von der Reihenfolge, in der die Teilausdrücke in den Klammern berechnet werden.
Die Reihenfolge der Auswertungen von Teilausdrücken (Operanden) ist undefiniert. Daher sollten Ausdrücke vermeiden werden, die einen Wert sowohl verändern als auch benutzen.
===Typkonvertierung ===
Verschiedene Datentypen können in einem Ausdruck oder in einer Zuweisung gemischt werden. Bei der Verknüpfung zweier Operanden unterschiedlicher Typen können einige Werte konvertiert (umgewandelt) werden.
Es gibt zwei verschiedene Mechanismen der Konvertierung:
1. Konvertierung ohne Informationsverlust.
2. Konvertierung mit Informationsverlust.
Typkonvertierungen mit Informationsverlust sind gefährlich und sollen möglichst vermieden werden.
(n == 0)? 1: z/n; // Quotient z/n
// oder 1, falls der Nenner 0 ist
a>b ? a : b; // Maximum zweier Zahlen
===Assoziativität===
In einem Ausdruck können Operatoren gleicher Prioritätsstufe vorkommen, z.B.: 5+4-3 oder 5+4+3
Dabei wird die Ausführungsreihenfolge durch die Assoziativität der Operatoren bestimmt:
1. Linksassoziativität (in Links-Rechts-Richtung)
2. Rechtsassoziativität (in Rechts-Links-Richtung)
Die Operatoren +, -, *, / werden von links nach rechts abgearbeitet. Die Assoziativität der Operatoren wird in der Operatoren-Tabelle angegeben.
Man sollte in komplexeren Ausdrücken, in denen arithmetische, relationale und logische Operatoren gemischt vorkommen, lieber Klammern setzen, um jedes Mißverständnis auszuschließen.
===Auswertung der Operanden ===
Ein Operand ist ein Literal oder ein Variablenname oder ein Konstantenname oder ein Teilausdruck in runden
Klammern.
Beispiel: int x=0;
int sum = (x=3) + (++x);
Die Variable sum kann hier den Wert 4 oder den wert 7 annehmen, abhängig von der Reihenfolge, in der die Teilausdrücke in den Klammern berechnet werden.
Die Reihenfolge der Auswertungen von Teilausdrücken (Operanden) ist undefiniert. Daher sollten Ausdrücke vermeiden werden, die einen Wert sowohl verändern als auch benutzen.
===Typkonvertierung ===
Verschiedene Datentypen können in einem Ausdruck oder in einer Zuweisung gemischt werden. Bei der Verknüpfung zweier Operanden unterschiedlicher Typen können einige Werte konvertiert (umgewandelt) werden.
Es gibt zwei verschiedene Mechanismen der Konvertierung:
1. Konvertierung ohne Informationsverlust.
2. Konvertierung mit Informationsverlust.
Typkonvertierungen mit Informationsverlust sind gefährlich und sollen möglichst vermieden werden.
Deletions:
(n == 0)? 1: z/n; // Quotient z/n
// oder 1, falls der Nenner 0 ist
a>b ? a : b; // Maximum zweier Zahlen
Additions:
===Bedingungsoperator ?===
Dieser Operator ist einziger, der drei Operanden benötigt. Die Syntax:
Bedingung ? Ausdruck1 : Ausdruck2;
Falls die Bedingung zutrifft, wird der erste Ausdruck ausgeführt, ansonsten der zweite Ausdruck. Der alternative Ausdruck wird ignoriert. Der Bedingungsoperator kann für kompakte Formulierungen benutzt werden, z.B.:
%%(cpp)
(x > 0)? x: -x; // Absolutwert von x
(n == 0)? 1: z/n; // Quotient z/n
// oder 1, falls der Nenner 0 ist
a>b ? a : b; // Maximum zweier Zahlen
%%
=====3.4. Auswertung =====
Priorität
In einem Ausdruck können verschiedene Operanden gemischt werden, z.B. hat der Ausdruck 2*3 + 4*5 den Wert 26.
Wenn Operatoren unterschiedlicher Prioritäten nebeneinander stehen, werden sie in der Reihenfolge fallender Priorität angewendet. Es gelten im Allgemeinen Vorrangregeln (Prioritäten) der Algebra. Multiplikation und Division werden, wie gewohnt,
vor Addition und Subtraktion ausgeführt.
Alle Operatoren sind in der Operatorentabelle zusammengefasst. In der Tabelle werden auch Prioritäten angegeben. Kleine Prioritäten werden in dieser Tabelle mit kleinen Rangzahlen bezeichnet .
""⇒"" Demo 6. Operatorentabelle
Dieser Operator ist einziger, der drei Operanden benötigt. Die Syntax:
Bedingung ? Ausdruck1 : Ausdruck2;
Falls die Bedingung zutrifft, wird der erste Ausdruck ausgeführt, ansonsten der zweite Ausdruck. Der alternative Ausdruck wird ignoriert. Der Bedingungsoperator kann für kompakte Formulierungen benutzt werden, z.B.:
%%(cpp)
(x > 0)? x: -x; // Absolutwert von x
(n == 0)? 1: z/n; // Quotient z/n
// oder 1, falls der Nenner 0 ist
a>b ? a : b; // Maximum zweier Zahlen
%%
=====3.4. Auswertung =====
Priorität
In einem Ausdruck können verschiedene Operanden gemischt werden, z.B. hat der Ausdruck 2*3 + 4*5 den Wert 26.
Wenn Operatoren unterschiedlicher Prioritäten nebeneinander stehen, werden sie in der Reihenfolge fallender Priorität angewendet. Es gelten im Allgemeinen Vorrangregeln (Prioritäten) der Algebra. Multiplikation und Division werden, wie gewohnt,
vor Addition und Subtraktion ausgeführt.
Alle Operatoren sind in der Operatorentabelle zusammengefasst. In der Tabelle werden auch Prioritäten angegeben. Kleine Prioritäten werden in dieser Tabelle mit kleinen Rangzahlen bezeichnet .
""⇒"" Demo 6. Operatorentabelle
Additions:
Beispiel: b wird true, wenn c einen Buchstabe enthält.
char c; bool b;
""b= (c >= ‟a‟) && (c <= ‟z‟) || (c >= ‟A‟) && (c <= ‟Z‟); ""
char c; bool b;
""b= (c >= ‟a‟) && (c <= ‟z‟) || (c >= ‟A‟) && (c <= ‟Z‟); ""
Additions:
Legende: T - true, F- false;
In logischen Ausdrücken werden die Operatoren nach ihren Prioritäten ausgeführt:
zuerst
danach
zuletzt
!
&&
||
In logischen Ausdrücken werden die Operatoren nach ihren Prioritäten ausgeführt:
zuerst
danach
zuletzt
!
&&
||
Additions:
!a
Logische Negation
a && b
Logisches UND
a || b
Logisches ODER
a ==b
gleich
a != b
ungleich
Vergleichsoperatoren können als Operanden für die logischen Operatoren verwendet werden.
Beispiele: "" int x; bool b; b= (x>3) && (x<5); ""
b erhält „true“, wenn x gleich 4 ist.
===Wahrheitstabellen===
Für die Auswertung von logischen Operatoren gelten die von der Boole'schen Algebra bekannten Wahrheitstabellen:
<b>&&</b>
<b>||</b>
<b>!</b>
T && T -> T
T || T -> T
! T -> F
T && F -> F
T || F -> T
! F -> T
F && T -> F
F || T -> T
F && F -> F
F || F -> F
Logische Negation
a && b
Logisches UND
a || b
Logisches ODER
a ==b
gleich
a != b
ungleich
Vergleichsoperatoren können als Operanden für die logischen Operatoren verwendet werden.
Beispiele: "" int x; bool b; b= (x>3) && (x<5); ""
b erhält „true“, wenn x gleich 4 ist.
===Wahrheitstabellen===
Für die Auswertung von logischen Operatoren gelten die von der Boole'schen Algebra bekannten Wahrheitstabellen:
<b>&&</b>
<b>||</b>
<b>!</b>
T && T -> T
T || T -> T
! T -> F
T && F -> F
T || F -> T
! F -> T
F && T -> F
F || T -> T
F && F -> F
F || F -> F
Additions:
Logischer Datentyp wurde in ""C++ ""eingeführt und mit bool bezeichnet zur Erinnerung an den Mathematiker G. Boole.
!! if ((i < 0) && (j < 100)) ... !!
!! if ((i < 0) && (j < 100)) ... !!
Deletions:
if ((i < 0) && (j < 100)) ...
Additions:
===Operatoren und Variablen für Zeichen ===
Da der Datentyp char intern als eine 1-Byte-Ganzzahl dargestellt wird, sind alle Ganzzahl-Operatoren im Prinzip möglich.
Im Sinne der Bedeutung von Zeichen sind nur die Vergleichsoperatoren sinnvoll.
Einige Schlüsselwörter können verwendet werden, um Variablen und Konstanten zu definieren.
Beispiele: char a= „a„;
unsigned char b = 1;
const char c= „c„;
===Logischer Datentyp ===
**1.Bezeichnungen**
Logischer Datentyp wurde in C++ eingeführt und mit bool bezeichnet zur Erinnerung an den Mathematiker G. Boole.
**2.Werte**
Es gibt nur zwei Wahrheitswerte true und false. Vergleichsoperatoren von Zahlendatentypen liefern die Ergebnisse vom Datentyp bool, z.B.: 3 < 4 ergibt true.
**3.Literale**
Literale des bool-Typs sind true und false und werden im Programm genau so notiert.
**4.Variablen**
Variablen können nur die Wahrheitswerte true und false annehmen, z.B.: bool a=true; bool b=3<4;
**5.Interne Darstellung**
Der Wert true wird intern als ganze Zahl 1 und false als 0 dargestellt.
Die Umwandlung von Zahlentypen nach bool ergibt false nur für 0 und true für alle anderen Zahlen.
**6.Verwendung**
Logische Werte werden oft in Kontrollstrukturen verwendet, z.B.:
if ((i < 0) && (j < 100)) ...
===Operatoren für logische Datentypen===
Boole'sche Werte können mit den logischen Operatoren und Vergleichsoperatoren verknüpft werden.
Da der Datentyp char intern als eine 1-Byte-Ganzzahl dargestellt wird, sind alle Ganzzahl-Operatoren im Prinzip möglich.
Im Sinne der Bedeutung von Zeichen sind nur die Vergleichsoperatoren sinnvoll.
Einige Schlüsselwörter können verwendet werden, um Variablen und Konstanten zu definieren.
Beispiele: char a= „a„;
unsigned char b = 1;
const char c= „c„;
===Logischer Datentyp ===
**1.Bezeichnungen**
Logischer Datentyp wurde in C++ eingeführt und mit bool bezeichnet zur Erinnerung an den Mathematiker G. Boole.
**2.Werte**
Es gibt nur zwei Wahrheitswerte true und false. Vergleichsoperatoren von Zahlendatentypen liefern die Ergebnisse vom Datentyp bool, z.B.: 3 < 4 ergibt true.
**3.Literale**
Literale des bool-Typs sind true und false und werden im Programm genau so notiert.
**4.Variablen**
Variablen können nur die Wahrheitswerte true und false annehmen, z.B.: bool a=true; bool b=3<4;
**5.Interne Darstellung**
Der Wert true wird intern als ganze Zahl 1 und false als 0 dargestellt.
Die Umwandlung von Zahlentypen nach bool ergibt false nur für 0 und true für alle anderen Zahlen.
**6.Verwendung**
Logische Werte werden oft in Kontrollstrukturen verwendet, z.B.:
if ((i < 0) && (j < 100)) ...
===Operatoren für logische Datentypen===
Boole'sche Werte können mit den logischen Operatoren und Vergleichsoperatoren verknüpft werden.
Additions:
Es gibt besondere Zeichen der ASCII-Tabelle, die meistens unsichtbar sind. Um sie darstellen zu können, werden ihre Literale als Folge zweier Zeichen geschrieben. Sie heißen Escape-Sequenzen, weil sie der normalen Zeichen-Interpretation entkommen (escape).
Einige Beispiele:
<b>Bedeutung und
ASCII-Name </b>
<b>Interner Wert
(dezimal) </b>
\0
Nullbyte, NUL
0
\a
Signalton, BEL
7
\t
Tabulator, HT
9
\n
Neue Zeile, LF
10
\\
Backslash, \
92
\ddd
3 Oktalziffern
ddd(oktal)
Einige Beispiele:
<b>Bedeutung und
ASCII-Name </b>
<b>Interner Wert
(dezimal) </b>
\0
Nullbyte, NUL
0
\a
Signalton, BEL
7
\t
Tabulator, HT
9
\n
Neue Zeile, LF
10
\\
Backslash, \
92
\ddd
3 Oktalziffern
ddd(oktal)
Additions:
===Zeichen-Literale===
Literale bestehen aus einem Zeichen, welches zwischen zwei einfachen Hochkommata eingeschlossen wird. Ein Zeichen hat eine eingeutige Position innerhalb der ASCII-Tabelle. Einige Beispiele aus der ASCII-Tabelle:
<b>Zeichen</b>
<b>Bedeutung </b>
<b>Interner Wert (dezimal) </b>
‟ A‟
Großbuchstabe A
65
‟ a‟
Kleinbuchstabe a
<td>97
‟ ‟
Leerzeichen
32
‟.‟
Punkt
46
‟0‟
Ziffer 0
48
Literale bestehen aus einem Zeichen, welches zwischen zwei einfachen Hochkommata eingeschlossen wird. Ein Zeichen hat eine eingeutige Position innerhalb der ASCII-Tabelle. Einige Beispiele aus der ASCII-Tabelle:
<b>Zeichen</b>
<b>Bedeutung </b>
<b>Interner Wert (dezimal) </b>
‟ A‟
Großbuchstabe A
65
‟ a‟
Kleinbuchstabe a
<td>97
‟ ‟
Leerzeichen
32
‟.‟
Punkt
46
‟0‟
Ziffer 0
48
Additions:
"" float a=0; for(int i=0; i<1000000; i++) a=a+0.1f; ""
""cout<< a; //100958.3437500000 ""
""cout<< a; //100958.3437500000 ""
Deletions:
cout<< a; //100958.3437500000
Additions:
""cout<< (a== 100000.0f); //false ""
Deletions:
Additions:
===Berechnungen mit Gleitkommazahlen===
Aufgrund der Genauigkeitsgrenzen ergeben sich Unterschiede zwischen rein mathematischen Berechnungen und Computerberechnungen:
1) Kumulierte Rundungsfehler entstehen bei der Summe von Gleitkommazahlen mit Rundungsfehlern. Dabei werden Rundungsfehler kumuliert, z.B.:
float a=0; for(int i=0; i<1000000; i++) a=a+0.1f;
cout<< a; //100958.3437500000
Mathematisches Ergebnis ist 100000. Als eine Alternative kann die Multiplikation verwendet werden.
2) Die Abfrage auf Gleichheit kann falsches Ergebnis liefern, da aufgrund von Rundungsfehlern zwei Gleitkommazahlen selten gleich sind, z.B.:
cout<< (a== 100000.0f); //false
3) Bei der Subtraktion zweier fast gleich großer Werte heben sich die signifikanten Ziffern auf. Die Differenz wird somit ungenau. Dieser Effekt ist unter dem Namen numerische Auslöschung bekannt.
4) Ergebnisse können von der Reihenfolge der Berechnung abhängen.
Für den Fehler ist der Programmierer verantwortlich. Er muss durch die Wahl eines geeigneten Datentyps und einer geeigneten Reihenfolge dafür sorgen, dass das Ergebnis der erwarteten Genauigkeit entspricht.
""⇒"" Demo 4. Auslöschung
=====3.3. Nichtnumerische Datentypen =====
===Der Datentyp char===
Der Datentyp char kann auf zwei unterschiedliche Arten verwendet werden:
1) Ein char-Wert dient der Darstellung von einzelnen Zeichen wie 'a', 'A', 'b', 'B', '5', '7', '§' usw. für Tastatureingabe und Bildschirmausgabe.
char-Werte sind intern eine 1-Byte-Ganzzahl und werden durch entsprechenden Zeichencode (ASCII-Code) als Zeichen interpretiert.
2) Ein char kann genutzt werden, um kleine Ganzzahlen zu verarbeiten.
<b>Typ und Größe in Bytes </b>
<b>Wertebereich </b>
char
1
–128 bis +127
<tr>
unsigned char
1
0 bis 255
Aufgrund der Genauigkeitsgrenzen ergeben sich Unterschiede zwischen rein mathematischen Berechnungen und Computerberechnungen:
1) Kumulierte Rundungsfehler entstehen bei der Summe von Gleitkommazahlen mit Rundungsfehlern. Dabei werden Rundungsfehler kumuliert, z.B.:
float a=0; for(int i=0; i<1000000; i++) a=a+0.1f;
cout<< a; //100958.3437500000
Mathematisches Ergebnis ist 100000. Als eine Alternative kann die Multiplikation verwendet werden.
2) Die Abfrage auf Gleichheit kann falsches Ergebnis liefern, da aufgrund von Rundungsfehlern zwei Gleitkommazahlen selten gleich sind, z.B.:
cout<< (a== 100000.0f); //false
3) Bei der Subtraktion zweier fast gleich großer Werte heben sich die signifikanten Ziffern auf. Die Differenz wird somit ungenau. Dieser Effekt ist unter dem Namen numerische Auslöschung bekannt.
4) Ergebnisse können von der Reihenfolge der Berechnung abhängen.
Für den Fehler ist der Programmierer verantwortlich. Er muss durch die Wahl eines geeigneten Datentyps und einer geeigneten Reihenfolge dafür sorgen, dass das Ergebnis der erwarteten Genauigkeit entspricht.
""⇒"" Demo 4. Auslöschung
=====3.3. Nichtnumerische Datentypen =====
===Der Datentyp char===
Der Datentyp char kann auf zwei unterschiedliche Arten verwendet werden:
1) Ein char-Wert dient der Darstellung von einzelnen Zeichen wie 'a', 'A', 'b', 'B', '5', '7', '§' usw. für Tastatureingabe und Bildschirmausgabe.
char-Werte sind intern eine 1-Byte-Ganzzahl und werden durch entsprechenden Zeichencode (ASCII-Code) als Zeichen interpretiert.
2) Ein char kann genutzt werden, um kleine Ganzzahlen zu verarbeiten.
<b>Typ und Größe in Bytes </b>
<b>Wertebereich </b>
char
1
–128 bis +127
<tr>
unsigned char
1
0 bis 255
Additions:
Zum Vergleich: dezimal 1/3 wird binär zu 0.01""<span style="color:blue;">01</span>""01""<span style="color:blue;">01</span>""...
Deletions:
Additions:
6. ""C/C++"" kennt keinen Potenzierungs-Operator.
""cout<< 1.e200/1.e-200;"" "" //infinity (unendlich) ""
c""out<<1.e-200*1.e-200""; ""//0 ""
===Genauigkeit===
Wegen der Diskretheit können reelle Zahlen als Gleitkommazahlen nur mit einer bestimmten Genauigkeit abgebildet werden. Anders gesagt, eine Gleitkommazahl besitzt nicht beliebig viele signifikante Stellen.
Mehrere reelle Zahlen haben die unendliche periodische oder nicht periodische Ziffernfolge und daher können nur mit Rundungsfehler dargestellt werden, z.B.:
1/3 = 0,33333...
e = 2,718281828459... (eulersche Zahl)
Im Binärsystem tritt dieses Problem auch bei Zahlen mit endlicher Dezimaldarstellung auf, z.B.: dezimal 0.1 wird
binär zu 0.000""<span style="color:blue;">1100</span>""1100...
Zum Vergleich: dezimal 1/3 wird binär zu 0.01<span style="color:blue;">01</span>""01<span style="color:blue;">01</span>""...
""cout<< 1.e200/1.e-200;"" "" //infinity (unendlich) ""
c""out<<1.e-200*1.e-200""; ""//0 ""
===Genauigkeit===
Wegen der Diskretheit können reelle Zahlen als Gleitkommazahlen nur mit einer bestimmten Genauigkeit abgebildet werden. Anders gesagt, eine Gleitkommazahl besitzt nicht beliebig viele signifikante Stellen.
Mehrere reelle Zahlen haben die unendliche periodische oder nicht periodische Ziffernfolge und daher können nur mit Rundungsfehler dargestellt werden, z.B.:
1/3 = 0,33333...
e = 2,718281828459... (eulersche Zahl)
Im Binärsystem tritt dieses Problem auch bei Zahlen mit endlicher Dezimaldarstellung auf, z.B.: dezimal 0.1 wird
binär zu 0.000""<span style="color:blue;">1100</span>""1100...
Zum Vergleich: dezimal 1/3 wird binär zu 0.01<span style="color:blue;">01</span>""01<span style="color:blue;">01</span>""...
Deletions:
cout<< 1.e200/1.e-200; //infinity (unendlich)
cout<<1.e-200*1.e-200; //0
Additions:
===Operatoren für Gleitkommazahlen===
1. Vorzeichenoperatoren.
2. Arithmetische Operatoren: Addition, Subtraktion, Multiplikation, Division.
3. Der Modulo-Operator ist nicht anwendbar.
4. Kombinierte Zuweisungen.
5. Vergleichsoperatoren.
6. C/C++ kennt keinen Potenzierungs-Operator.
===Bereichsüberschreitungen===
Aufgrund der endlichen Größe des Exponenten gibt es zwei Arten von Bereichsüberschreitungen:
1. Ein Überlauf (overflow) tritt auf, wenn das Ergebnis einer Berechnung betragsmäßig größer als die größte darstellbare Zahl ist.
Die Division durch zu kleiner Werte ergibt einen Überlauf.
Beispiel:
cout<< 1.e200/1.e-200; //infinity (unendlich)
2. Ein Unterlauf (underflow) tritt auf, wenn das Ergebnis betragsmäßig kleiner als die kleinste darstellbare Zahl ist. Das Resultat wird dann gleich 0 gesetzt.
Beispiel:
cout<<1.e-200*1.e-200; //0
1. Vorzeichenoperatoren.
2. Arithmetische Operatoren: Addition, Subtraktion, Multiplikation, Division.
3. Der Modulo-Operator ist nicht anwendbar.
4. Kombinierte Zuweisungen.
5. Vergleichsoperatoren.
6. C/C++ kennt keinen Potenzierungs-Operator.
===Bereichsüberschreitungen===
Aufgrund der endlichen Größe des Exponenten gibt es zwei Arten von Bereichsüberschreitungen:
1. Ein Überlauf (overflow) tritt auf, wenn das Ergebnis einer Berechnung betragsmäßig größer als die größte darstellbare Zahl ist.
Die Division durch zu kleiner Werte ergibt einen Überlauf.
Beispiel:
cout<< 1.e200/1.e-200; //infinity (unendlich)
2. Ein Unterlauf (underflow) tritt auf, wenn das Ergebnis betragsmäßig kleiner als die kleinste darstellbare Zahl ist. Das Resultat wird dann gleich 0 gesetzt.
Beispiel:
cout<<1.e-200*1.e-200; //0
Additions:
===Gleitkomma-Literale ===
Literale können folgende Bestandteile haben:
1. Vorzeichen
2. Vorkommaanteil
3. Dezimalpunkt
4. Nachkommaanteil
5. Buchstaben e oder E
6. Vorzeichen des Exponenten .
7. Wert des Exponenten
8. Suffix F, f -für float und l -für long double
Dabei darf fehlen:
1) entweder der Vor- oder der Nachkommaanteil (wird als 0 angenommen);
2) jedes der Vorzeichen (wird als + angenommen);
3) entweder der Dezimalpunkt (wird als 0 angenommen) oder der Exponent (wird als 10""<sup>0</sup>"" = 1 angenommen);
4) Suffix (wird als double angenommen).
Beispiel: -2.3E-1F entspricht -2.3·10""<sup>-1</sup>"" float.
Literale können folgende Bestandteile haben:
1. Vorzeichen
2. Vorkommaanteil
3. Dezimalpunkt
4. Nachkommaanteil
5. Buchstaben e oder E
6. Vorzeichen des Exponenten .
7. Wert des Exponenten
8. Suffix F, f -für float und l -für long double
Dabei darf fehlen:
1) entweder der Vor- oder der Nachkommaanteil (wird als 0 angenommen);
2) jedes der Vorzeichen (wird als + angenommen);
3) entweder der Dezimalpunkt (wird als 0 angenommen) oder der Exponent (wird als 10""<sup>0</sup>"" = 1 angenommen);
4) Suffix (wird als double angenommen).
Beispiel: -2.3E-1F entspricht -2.3·10""<sup>-1</sup>"" float.
Additions:
Gleitkommatypen unterscheiden sich nicht nur in der Größe des Wertebereichs, sondern auch in der Genauigkeit der Darstellung.
Durch die Genauigkeit bezeichnet man, wie viele signifikanten Stellen einer Dezimalzahl im jeweiligen Typ dargestellt werden können.
<b>float </b>
<b>double </b>
</td>
<b>long double </b>
</td>
<b>Stellen</b>
ca. 6
ca. 15
ca. 18
""⇒"" Demo 3. Gleitpunkttypen
Durch die Genauigkeit bezeichnet man, wie viele signifikanten Stellen einer Dezimalzahl im jeweiligen Typ dargestellt werden können.
<b>float </b>
<b>double </b>
</td>
<b>long double </b>
</td>
<b>Stellen</b>
ca. 6
ca. 15
ca. 18
""⇒"" Demo 3. Gleitpunkttypen
Additions:
===Gleitkomma-Typen===
Es gibt verschiedene Darstellungen von Gleitkommazahlen:
<b>Typ</b>
<b>Größe in Bytes und Wertebereich </b>
float
4
±1.1E-38 bis ±3.4E+38
double
8
±2.2E-308 bis ±1.7E+308
long double
12
±3.3E-4932 bis ±1.1E+4932
Es gibt verschiedene Darstellungen von Gleitkommazahlen:
<b>Typ</b>
<b>Größe in Bytes und Wertebereich </b>
float
4
±1.1E-38 bis ±3.4E+38
double
8
±2.2E-308 bis ±1.7E+308
long double
12
±3.3E-4932 bis ±1.1E+4932
Additions:
short a=32767; ""a=a+1;"" ""cout<<a;"" ""//-32768""
Deletions:
Additions:
**1. Traditionelle arithmetische Operatoren **
**2. Kombinierte Zuweisungen** (erweiterte arithmetische Operatoren, Kurzform-Operatoren), z.B.:
**3. Inkrement- und Dekrement -Operatoren** (unär)
**4. Vergleichsoperatoren** (relationale Operatoren)
Diese Operatoren sind binär.
**5. Bitoperatoren **
Weil ganze Zahlen auch als Bitvektoren aufgefasst werden können, sind zusätzlich 11 die so genannten Bit-Operatoren möglich.
===Bereichsüberschreitung===
In der Mathematik haben ganze Zahlen einen unendlichen Zahlenbereich. Auf Rechnern haben ganze Zahlen dagegen begrenzte Zahlenbereiche. Ein Überlauf (Bereichsüberschreitung, arithmetischer Überlauf, overflow) tritt auf, wenn das Ergebnis einer
Berechnung für den gültigen Zahlenbereich zu groß ist.
**Beispiel: **
short a=32767; a=a+1; cout<<a; //-32768
**Erklärung**:
Der short–Zahlenbereich ist von - 32 768 bis 32 767.
**Anmerkung:**
Die gebräuchliche interne Darstellung ganzer Zahlen ist die so genannte Zweierkomplementdarstellung.
Für den Fehler ist der Programmierer verantwortlich. Es gibt zwei Möglichkeiten:
1. Durch die Wahl eines geeigneten Datentyps muss gesichert werden, dass der Bereich nicht überschritten wird.
2. Der Überlauf muss auf die eine oder andere Art dem Benutzer gemeldet werden, damit er entsprechend darauf reagieren kann.
Überschreitungen führen zu schweren Konsequenzen. Ein berühmtes Beispiel ist die Explosion der Rakete „Ariane-5“ am 4. Juni 1996. Der Grund dieser milliardenteuren Panne war der Überlauf der 16-Bit-Variablen.
=====3.2. Gleitkomma-Datentypen =====
**Reelle Zahlen **
1. Reelle Zahlen können für die Repräsentation von messbaren Größen verwendet werden. Reelle Zahlen werden unterteilt in rationale und irrationale.
2. Eine rationale (gebrochene) Zahl ist eine Zahl, die als Verhältnis (ratio) zweier ganzer Zahlen dargestellt werden kann. Rationale Zahlen bilden die Untermenge der reellen Zahlen.
3. Zu den irrationalen Zahlen gehören z.B. die Kreiszahl ∏ = 3,14159... und die Eulersche Zahl e = 2,71828...
4. Ganze Zahlen bilden die Untermenge der rationalen Zahlen.
5. Prinzipiell können reelle Zahlen als Kommazahl dargestellt werden. Statt des Kommas kann ein Dezimalpunkt verwendet werden.
**Gleitkommazahlen**
Gleitkommazahlen (Gleitpunkt-, Fließkomma-, Floatingpoint-Zahlen) repräsentieren reelle Zahlen in einem Rechner.
Gleitkommazahlen werden in der Hardware durch eine Basis (B), eine Mantisse (M) und einen Exponenten (E) abgelegt:
M*B""<sup>E</sup>"".
Die Mantisse legt die Genauigkeit fest, der Exponent bestimmt die Größenordnung der Zahl.
Eigenschaften:
1. Die Exponentialdarstellung ist für Berechnungen mit sehr kleinen oder sehr großen Zahlen geeignet.
2. Im Gegensatz zu ganzen Zahlen können reelle Zahlen als Gleitkommazahlen nur mit einer bestimmten Genauigkeit abgebildet werden.
Anmerkung 1:
Im Computer wird das Binärsystem und darum die Basis B=2 verwendet.
Anmerkung 2:
Gleitkommazahlen können manchmal auch´als reelle Zahlen oder als gebrochene Zahlen bezeichnet werden.
Anmerkung 3:
Ungeachtet der internen Darstellung können die Gleitkommazahlen im Programm oder bei der Ausgabe in den zwei gebräuchlichen Formaten dargestellt werden: als Festkommazahl und als Gleitkommazahl (Exponentialschreibweise).
Beispiele:
0.0003""<sup>4</sup>"" - Festkommazahl,
3.4*10""<sup>4</sup>"" - Gleitkommazahl.
**2. Kombinierte Zuweisungen** (erweiterte arithmetische Operatoren, Kurzform-Operatoren), z.B.:
**3. Inkrement- und Dekrement -Operatoren** (unär)
**4. Vergleichsoperatoren** (relationale Operatoren)
Diese Operatoren sind binär.
**5. Bitoperatoren **
Weil ganze Zahlen auch als Bitvektoren aufgefasst werden können, sind zusätzlich 11 die so genannten Bit-Operatoren möglich.
===Bereichsüberschreitung===
In der Mathematik haben ganze Zahlen einen unendlichen Zahlenbereich. Auf Rechnern haben ganze Zahlen dagegen begrenzte Zahlenbereiche. Ein Überlauf (Bereichsüberschreitung, arithmetischer Überlauf, overflow) tritt auf, wenn das Ergebnis einer
Berechnung für den gültigen Zahlenbereich zu groß ist.
**Beispiel: **
short a=32767; a=a+1; cout<<a; //-32768
**Erklärung**:
Der short–Zahlenbereich ist von - 32 768 bis 32 767.
**Anmerkung:**
Die gebräuchliche interne Darstellung ganzer Zahlen ist die so genannte Zweierkomplementdarstellung.
Für den Fehler ist der Programmierer verantwortlich. Es gibt zwei Möglichkeiten:
1. Durch die Wahl eines geeigneten Datentyps muss gesichert werden, dass der Bereich nicht überschritten wird.
2. Der Überlauf muss auf die eine oder andere Art dem Benutzer gemeldet werden, damit er entsprechend darauf reagieren kann.
Überschreitungen führen zu schweren Konsequenzen. Ein berühmtes Beispiel ist die Explosion der Rakete „Ariane-5“ am 4. Juni 1996. Der Grund dieser milliardenteuren Panne war der Überlauf der 16-Bit-Variablen.
=====3.2. Gleitkomma-Datentypen =====
**Reelle Zahlen **
1. Reelle Zahlen können für die Repräsentation von messbaren Größen verwendet werden. Reelle Zahlen werden unterteilt in rationale und irrationale.
2. Eine rationale (gebrochene) Zahl ist eine Zahl, die als Verhältnis (ratio) zweier ganzer Zahlen dargestellt werden kann. Rationale Zahlen bilden die Untermenge der reellen Zahlen.
3. Zu den irrationalen Zahlen gehören z.B. die Kreiszahl ∏ = 3,14159... und die Eulersche Zahl e = 2,71828...
4. Ganze Zahlen bilden die Untermenge der rationalen Zahlen.
5. Prinzipiell können reelle Zahlen als Kommazahl dargestellt werden. Statt des Kommas kann ein Dezimalpunkt verwendet werden.
**Gleitkommazahlen**
Gleitkommazahlen (Gleitpunkt-, Fließkomma-, Floatingpoint-Zahlen) repräsentieren reelle Zahlen in einem Rechner.
Gleitkommazahlen werden in der Hardware durch eine Basis (B), eine Mantisse (M) und einen Exponenten (E) abgelegt:
M*B""<sup>E</sup>"".
Die Mantisse legt die Genauigkeit fest, der Exponent bestimmt die Größenordnung der Zahl.
Eigenschaften:
1. Die Exponentialdarstellung ist für Berechnungen mit sehr kleinen oder sehr großen Zahlen geeignet.
2. Im Gegensatz zu ganzen Zahlen können reelle Zahlen als Gleitkommazahlen nur mit einer bestimmten Genauigkeit abgebildet werden.
Anmerkung 1:
Im Computer wird das Binärsystem und darum die Basis B=2 verwendet.
Anmerkung 2:
Gleitkommazahlen können manchmal auch´als reelle Zahlen oder als gebrochene Zahlen bezeichnet werden.
Anmerkung 3:
Ungeachtet der internen Darstellung können die Gleitkommazahlen im Programm oder bei der Ausgabe in den zwei gebräuchlichen Formaten dargestellt werden: als Festkommazahl und als Gleitkommazahl (Exponentialschreibweise).
Beispiele:
0.0003""<sup>4</sup>"" - Festkommazahl,
3.4*10""<sup>4</sup>"" - Gleitkommazahl.
Deletions:
2. Kombinierte Zuweisungen (erweiterte arithmetische Operatoren, Kurzform-Operatoren), z.B.:
3. Inkrement- und Dekrement -Operatoren (unär)
4. Vergleichsoperatoren (relationale Operatoren) Diese Operatoren sind binär.
Additions:
a++
Postfix-Inkrement
a--
Postfix-Dekrement
++a
Präfix-Inkrement
--a
Präfix-Dekrement
Die ganzzahlige Variable „a“ ist der Operand des Operators.
Alle vier Operatoren verändern den Wert des Operandes
und liefern den Wert des Operandes als Ergebnis zurück.
Unter Inkrementierung wird Addition von 1 verstanden, unter Dekrementierung die Subtraktion von 1.
Präfix-Operator liefert den veränderten Wert. Postfix-Operator liefert den ursprünglichen Wert.
4. Vergleichsoperatoren (relationale Operatoren) Diese Operatoren sind binär.
<
kleiner als
>
größer als
<=
kleiner als oder gleich
>=
größer als oder gleich
==
gleich
!=
ungleich
Postfix-Inkrement
a--
Postfix-Dekrement
++a
Präfix-Inkrement
--a
Präfix-Dekrement
Die ganzzahlige Variable „a“ ist der Operand des Operators.
Alle vier Operatoren verändern den Wert des Operandes
und liefern den Wert des Operandes als Ergebnis zurück.
Unter Inkrementierung wird Addition von 1 verstanden, unter Dekrementierung die Subtraktion von 1.
Präfix-Operator liefert den veränderten Wert. Postfix-Operator liefert den ursprünglichen Wert.
4. Vergleichsoperatoren (relationale Operatoren) Diese Operatoren sind binär.
<
kleiner als
>
größer als
<=
kleiner als oder gleich
>=
größer als oder gleich
==
gleich
!=
ungleich
Additions:
===Ganzzahlige Variablen und Konstanten===
Um Variablen und Konstanten zu definieren, werden spezielle Schlüsselwörter verwendet: int, short, long, const.
Durch “unsigned” werden Variablen für natürliche Zahlen (ohne Vorzeichen) definiert.
Beispiele:
int a= -3;
unsigned short b = 65 534U;
const int c=5;
===Operatoren für ganze Zahlen===
1. Traditionelle arithmetische Operatoren
+ -
Vorzeichenoperatoren (unär)
+ - <br/>
* /
Addition, Subtraktion, <br/>
Multiplikation, Division (binär)
%
Modulo-Operator (binär)
Diese Operatoren haben ganzzahlige Operanden und auch ganzzahliges Ergebnis. Deswegen wird der Rest der ganzzahligen Division abgeschnitten. Bei Bedarf kann der Rest mit dem Modulo-Operator ermittelt werden.
Beispiel: für int a=9, b=5; ist a/b gleich 1 und a%b gleich 4.
2. Kombinierte Zuweisungen (erweiterte arithmetische Operatoren, Kurzform-Operatoren), z.B.:
a += b; bedeutet a = a + b;
3. Inkrement- und Dekrement -Operatoren (unär)
Um Variablen und Konstanten zu definieren, werden spezielle Schlüsselwörter verwendet: int, short, long, const.
Durch “unsigned” werden Variablen für natürliche Zahlen (ohne Vorzeichen) definiert.
Beispiele:
int a= -3;
unsigned short b = 65 534U;
const int c=5;
===Operatoren für ganze Zahlen===
1. Traditionelle arithmetische Operatoren
+ -
Vorzeichenoperatoren (unär)
+ - <br/>
* /
Addition, Subtraktion, <br/>
Multiplikation, Division (binär)
%
Modulo-Operator (binär)
Diese Operatoren haben ganzzahlige Operanden und auch ganzzahliges Ergebnis. Deswegen wird der Rest der ganzzahligen Division abgeschnitten. Bei Bedarf kann der Rest mit dem Modulo-Operator ermittelt werden.
Beispiel: für int a=9, b=5; ist a/b gleich 1 und a%b gleich 4.
2. Kombinierte Zuweisungen (erweiterte arithmetische Operatoren, Kurzform-Operatoren), z.B.:
a += b; bedeutet a = a + b;
3. Inkrement- und Dekrement -Operatoren (unär)
Additions:
Datentypen „long” und “unsigned long” können die Größe von 4 oder 8 Bytes haben. Die tatsächlich verwendete Anzahl von Bytes variiert je nach Rechnersystem. Die Zahlen-bereiche sind in der Standardbibliothek (limits.h) zu finden.
""⇒"" Demo 2. Ganzzahlentypen
===Ganzzahlige Literale ===
Literale sind durch folgende Beispiele dargestellt:
<b>Datentyp </b>
<b>dezimal </b>
</td>
<b>oktal</b>
<b>hexadezimal</b>
255
<span style="color:blue">0</span>377
<span style="color:blue">0x</span>FF
65535<span style="color:blue">U</span>
<span style="color:blue">0</span>177777
<span style="color:blue">0x</span>FFFF
long
10<span style="color:blue">L</span>
<span style="color:blue">0</span>12<span style="color:blue">L</span>
<span style="color:blue">0x</span>A<span style="color:blue">L</span>
unsigned long
27<span style="color:blue">UL</span>
<span style="color:blue">0</span>33<span style="color:blue">UL</span>
<span style="color:blue">0x</span>1B<span style="color:blue">UL</span>
""⇒"" Demo 2. Ganzzahlentypen
===Ganzzahlige Literale ===
Literale sind durch folgende Beispiele dargestellt:
<b>Datentyp </b>
<b>dezimal </b>
</td>
<b>oktal</b>
<b>hexadezimal</b>
255
<span style="color:blue">0</span>377
<span style="color:blue">0x</span>FF
65535<span style="color:blue">U</span>
<span style="color:blue">0</span>177777
<span style="color:blue">0x</span>FFFF
long
10<span style="color:blue">L</span>
<span style="color:blue">0</span>12<span style="color:blue">L</span>
<span style="color:blue">0x</span>A<span style="color:blue">L</span>
unsigned long
27<span style="color:blue">UL</span>
<span style="color:blue">0</span>33<span style="color:blue">UL</span>
<span style="color:blue">0x</span>1B<span style="color:blue">UL</span>
Additions:
""C/C++ ""ist eine streng typisierte Programmiersprache. Jedes der folgenden Sprachkonstrukten hat einen festen Datentyp, der nicht geändert werden kann: Variablen, Konstanten, Literale, Objekte.
=====3.1. Ganzzahlige Datentypen =====
===Ganze Zahlen===
Ganzzahlige Typen unterstützen zwei Arten von Zahlen:
1. Die natürlichen Zahlen sind die beim Zählen verwendeten Zahlen. Sie umfassen alle Zahlen:
0, 1, 2, 3, 4, …
2. Als ganze Zahlen bezeichnet man die natürlichen Zahlen unter Hinzunahme der negativen Zahlen. Sie umfassen alle Zahlen:
…−2, −1, 0, 1, 2, …
Natürliche Zahlen bilden die Untermenge der ganzen Zahlen. Jede ganze Zahl wird im Computer exakt dargestellt.
===Zahlenbereiche ===
Es gibt verschiedene Typen von ganzen und natürlichen Zahlen:
""<table class="data" width="80%" style="border:0">
<tr>
<td>
<b>Typ</b>
</td>
<td colspan="2">
<b>Größe in Bytes und Wertebereich </b>
</td>
</tr>
<tr>
<td>
short
</td>
<td>
2
</td>
<td>
- 32 768 bis 32 767
</td>
</tr>
<tr>
<td>
unsigned short
</td>
<td>
2
</td>
<td>
0 bis 65 535
</td>
</tr>
<tr>
<td>
int
</td>
<td>
4
</td>
<td>
- 2 147 483 648 bis 2 147 483 647
</td>
</tr>
<tr>
<td>
unsigned int
</td>
<td>
4
</td>
<td>
0 bis 4 294 967 295
</td>
</tr>
</table>""
=====3.1. Ganzzahlige Datentypen =====
===Ganze Zahlen===
Ganzzahlige Typen unterstützen zwei Arten von Zahlen:
1. Die natürlichen Zahlen sind die beim Zählen verwendeten Zahlen. Sie umfassen alle Zahlen:
0, 1, 2, 3, 4, …
2. Als ganze Zahlen bezeichnet man die natürlichen Zahlen unter Hinzunahme der negativen Zahlen. Sie umfassen alle Zahlen:
…−2, −1, 0, 1, 2, …
Natürliche Zahlen bilden die Untermenge der ganzen Zahlen. Jede ganze Zahl wird im Computer exakt dargestellt.
===Zahlenbereiche ===
Es gibt verschiedene Typen von ganzen und natürlichen Zahlen:
""<table class="data" width="80%" style="border:0">
<tr>
<td>
<b>Typ</b>
</td>
<td colspan="2">
<b>Größe in Bytes und Wertebereich </b>
</td>
</tr>
<tr>
<td>
short
</td>
<td>
2
</td>
<td>
- 32 768 bis 32 767
</td>
</tr>
<tr>
<td>
unsigned short
</td>
<td>
2
</td>
<td>
0 bis 65 535
</td>
</tr>
<tr>
<td>
int
</td>
<td>
4
</td>
<td>
- 2 147 483 648 bis 2 147 483 647
</td>
</tr>
<tr>
<td>
unsigned int
</td>
<td>
4
</td>
<td>
0 bis 4 294 967 295
</td>
</tr>
</table>""
Deletions:
Additions:
===Begriffdefinition===
Daten sind logisch gruppierte Informationseinheiten, die übertragen oder gespeichert werden können.
Verschiedene Arten von Daten werden durch den so genannten Datentyp bestimmt. Daten werden dabei in einer speziellen Bitcodierung abgelegt. Ein Datentyp ist die Zusammenfassung von Wertebereichen und die zulässigen Operatoren.
Die Datentypen ermöglichen es einem Compiler zu überprüfen, ob der Programmierer richtige Operatoren für die Berechnung von Daten angegeben hat.
C/C++ ist eine streng typisierte Programmiersprache. Jedes der folgenden Sprachkonstrukten hat einen festen Datentyp, der nicht geändert werden kann: Variablen, Konstanten, Literale, Objekte.
===Klassifikation ===
Es gibt einfache und benutzerdefinierte Datentypen.
1. __Benutzerdefinierte __Datentypen müssen im Programm vor der Verwendung definiert werden.
2. __Einfache __(elementare, primitive, eingebaute, vordefinierte) Datentypen sind in der Sprache eingebaut und können in 2 Gruppen aufgeteilt werden:
a) Numerische Datentypen (Zahlentypen)
- Ganzzahlen und
- Gleitkommazahlen.
b) Nicht numerische (alphanumerische) Datentypen
- Wahrheitswerte und
- Zeichen.
===Beschreibung eines Datentyps===
Zur Beschreibung eines Datentyps gehören: Wertebereiche, Operatoren, Speicherbedarf, Konstruktionsregeln von Variablen, Konstanten und Literale.
Jede Dateneinheit benötigt Platz im Speicher. Je mehr Platz verfügbar ist, desto mehr Informationen lässt sich darin ablegen.
Der Bereich der darstellbaren Werte hängt davon ab, wie viele Bytes für den Datentyp reserviert werden.
Das Rechnen ist die namensgebende Aufgabe des Rechners. Wenn man mit dem Rechner rechnen will, sollte man die Arbeitsweise und die Grenzen den eingebauten Datentypen kennen.
===Zahlentypen===
Ganzzahlen und Gleitkommazahlen werden von der Hardware unterschiedlich unterstützt.
1. Ganzzahlen werden mit weniger Platzbedarf gespeichert und werden schneller als Gleitkommazahlen verarbeitet. Die gebräuchliche interne Darstellung ganzer Zahlen ist die Zweierkomplementdarstellung.
2. Gleitkommazahlen werden durch eine Mantisse und einen Exponenten dargestellt. Im Gegensatz zu den ganzzahligen Typen können die Zahlen im Gleitkommaformat nicht immer exakt dargestellt werden. Die Gleitkommatypen unterscheiden sich nicht nur in der Größe des Wertebereichs, sondern auch in der Genauigkeit der Darstellung.
""⇒"" Demo 1.
Daten sind logisch gruppierte Informationseinheiten, die übertragen oder gespeichert werden können.
Verschiedene Arten von Daten werden durch den so genannten Datentyp bestimmt. Daten werden dabei in einer speziellen Bitcodierung abgelegt. Ein Datentyp ist die Zusammenfassung von Wertebereichen und die zulässigen Operatoren.
Die Datentypen ermöglichen es einem Compiler zu überprüfen, ob der Programmierer richtige Operatoren für die Berechnung von Daten angegeben hat.
C/C++ ist eine streng typisierte Programmiersprache. Jedes der folgenden Sprachkonstrukten hat einen festen Datentyp, der nicht geändert werden kann: Variablen, Konstanten, Literale, Objekte.
===Klassifikation ===
Es gibt einfache und benutzerdefinierte Datentypen.
1. __Benutzerdefinierte __Datentypen müssen im Programm vor der Verwendung definiert werden.
2. __Einfache __(elementare, primitive, eingebaute, vordefinierte) Datentypen sind in der Sprache eingebaut und können in 2 Gruppen aufgeteilt werden:
a) Numerische Datentypen (Zahlentypen)
- Ganzzahlen und
- Gleitkommazahlen.
b) Nicht numerische (alphanumerische) Datentypen
- Wahrheitswerte und
- Zeichen.
===Beschreibung eines Datentyps===
Zur Beschreibung eines Datentyps gehören: Wertebereiche, Operatoren, Speicherbedarf, Konstruktionsregeln von Variablen, Konstanten und Literale.
Jede Dateneinheit benötigt Platz im Speicher. Je mehr Platz verfügbar ist, desto mehr Informationen lässt sich darin ablegen.
Der Bereich der darstellbaren Werte hängt davon ab, wie viele Bytes für den Datentyp reserviert werden.
Das Rechnen ist die namensgebende Aufgabe des Rechners. Wenn man mit dem Rechner rechnen will, sollte man die Arbeitsweise und die Grenzen den eingebauten Datentypen kennen.
===Zahlentypen===
Ganzzahlen und Gleitkommazahlen werden von der Hardware unterschiedlich unterstützt.
1. Ganzzahlen werden mit weniger Platzbedarf gespeichert und werden schneller als Gleitkommazahlen verarbeitet. Die gebräuchliche interne Darstellung ganzer Zahlen ist die Zweierkomplementdarstellung.
2. Gleitkommazahlen werden durch eine Mantisse und einen Exponenten dargestellt. Im Gegensatz zu den ganzzahligen Typen können die Zahlen im Gleitkommaformat nicht immer exakt dargestellt werden. Die Gleitkommatypen unterscheiden sich nicht nur in der Größe des Wertebereichs, sondern auch in der Genauigkeit der Darstellung.
""⇒"" Demo 1.
