Einführung /Grundbegriffe

3. Datentypen, Ausdrücke und Operatoren
­ Programm muß i.a. Daten zwischenspeichern
­ Speicherplatz muß bereitgestellt werden, der ansprechbar, reserviert ist
Ablegen & Wiederfinden
­ in höheren Programmiersprachen Arbeit mit bestimmten Speicherplätzen über
Vergabe von Namen = Variable
3.1 Variable
im Programm definierter Name für einen (beim Programmlauf) zu
reservierenden Speicherplatz im Arbeitsspeicher für Werte eines bestimmten Typs
Arbeit mit Variablen (Zuweisungen von Werten, Berechnungen) bedeutet
Zugriff auf den zugehörigen Speicherplatz
Deklaration in C:
Beispiel: int i; Deklaration der integer­Variablen mit Namen i
d.h. Bereitstellen von i.a. 4 Byte Speicherplatz (=32 bit)
im Arbeitsspeicher
i=3; Speicherung des Wertes 3=2^0+2^1(≙ 11 binär)
auf dem reservierten Speicherplatz
➘
000... ... ... ...0011
i Arbeitspeicher
­ in vielen höheren Programmiersprachen ist zur Reservierung eines Speicherplatzes, d.h.
der Einführung einer neuen Variablen ein Variablentyp mit anzugeben
­ der Variablentyp sagt dem Compiler wieviel Speicherplatz benötigt wird und wie er
zu strukturieren ist (zu interpretieren)
Variablentyp Variablenname;
1

3.2 Elementare Datentypen
­ Es gibt drei qualitativ unterschiedliche Basistypen von Daten:
ganze Zahlen, reelle Zahlen und alphanumerische Zeichen
­ Die Basistypen werden i.a. in eine Reihe von Untertypen ( die sogenannten elementaren
Typen) aufgesplittet.
­ Die Bezeichnungen der Typen ist sprachabhängig, z.B.
ganze Zahlen : int , long , short (in C)
integer, longint, word (in PASCAL)
INTEGER (in FORTRAN)
reelle Zahlen : float, double (in C)
real, extended (in PASCAL)
REAL, DOUBLE (in FORTRAN)
Zeichen : char (in C und in PASCAL)
(1) Integertypen
in C: int
Speicherbedarf:
CHARACTER (in FORTRAN)
short int kurz: short
long int kurz: long
­ Speicherplatz für int = Wortlänge des Rechners
­ heutzutage auf dem PC meist 4 Byte = 32 Bit
⇨ max. bzw. min. darstellbare Zahl:
32 Stellen = 32 Möglichkeiten für 0 oder 1 ⇨ 2^32 verschiedene Zahlen darstellbar
Sinnvolle Möglichkeiten:
(A) das erste Bit gleich 0 bedeutet positive Zahl
1 bedeutet negative Zahl
alle anderen Bits repräsentieren den Betrag der ganzen Zahl
Diese Darstellungsweise ist auf den ersten Blick sehr sympathisch, hat aber praktische
Nachteile, besonders bei der Addition negativeR Zahlen.

(B) Deshalb:
Kodierung in sog. Zweierkomplementdarstellung
Für negative ganze Zahlen bedeutet das:
­ Die Bitfolge der zugehörigen betragsgleichen positiven Zahl wird logisch
negiert, d.h. aus jeder 0 wird eine 1 und aus jeder 1 wird eine 0.
­ Anschließend wird zu der so erhaltenen Zahl eine 1 addiert.
Beispiel betrachten hier einen max. Umfang von 4 Bit: < C Typ short
⇨bei 32 Bit ist der Bereich: ­2 31 bis 2 31 ­1
2 31 negative Zahlen, 0 und 2 31 –1 positive Zahlen
Maximale Zahl = 2 31 –1 ~ 2 Mio.
Unterschiede zwischen long int, int, short int sind compilerabhängig
(2) Gleitkomma­Typen
Darstellung reeller Zahlen
Typen in C: float ... einfache Genauigkeit
double ... doppelte Genauigkeit
Was bedeutet einfach, was bedeutet doppelt genau?
Und was ist eigentlich eine Gleitkommazahl?
­ anderer Name: Maschinenzahl
Festkommadarstellung z.B. : 321.45
Gleitkommadarstellung : 3.2145*10 2 bzw. 0.32145*10 3
Prinzipielles Problem:
Da nur beschränkte Anzahl an Bytes zur Darstellung zur Verfügung steht, ist in der
Regel eine genaue Darstellung nicht möglich.
Irrationale Zahlen wie 2 oder die Eulersche Zahl e intern nie exakt darstellbar.
aber auch viele andere nicht.

­ interne Darstellung im Rechner:
x = (­1) v 0.m1 m2 mL 2 p
Vorzeichen
mi ... sind 0 oder 1, m1 = 1
p ... ist der Exponent (selbst wieder intern binär gespeichert),
m p M (d.h. Beschränkt)
v ... ist 0 oder 1
d.h. das Komma wird immer an der selben Stelle plaziert.
Speicherplatz:
Für die Codierung im Computer ist IEEE­Standard üblich
● für Gleitkommazahl in einfacher Genauigkeit: 4Byte = 32 Bit
v e7 ... e0 m2 ... ... m24
Vorzeichenbit Exponent Mantisse
m1 muß nicht gespeichert werden, da stets = 1
● für Gleitkommazahl in doppelter Genauigkeit: 8Byte = 64 Bit
v e10 ... ... e0 m2 ... ... ... ... ... m53
Vorzeichenbit Exponent Mantisse
Typ Max. /pos. Min. Rel. Rechengenauigkeit eps
float
double
Mantisse Basis + Exponent
~ 10 38 / ~ 10 ­38
~ 10 308 / ~ 10 ­308
z.B. MAXFLOAT ~ 2 M , M = 2 7 = 128 2 M = 2 128 ~ 10 38
⇨Mantisse bestimmt die Rechengenauigkeit
⇨Exponent bestimmt den Wertebereich
~ 0.610 ­7
~ 1.110 ­16

Grenzen der Maschinenzahlen:
Unterlauf (underflow): |x| < eps Rundung x=0
Überlauf (overflow) |x| > MAX_Typ compilerabhängige Reaktion
­ Abbruch + Fehlermeldung
­ falsches Ergebnis
­ x=INF oder x=NaN
Bei der Darstellung selbst einfachster Dezimalzahlen treten schon Rundungsfehler auf.
Zusätzlich ergeben sich beim Rechnen weitere Rundungsfehler:
Bei Addition zweier (positiver) Gleitkommazahlen werden folgende Einzelschritte
ausgeführt:
1. Erkennen von Mantisse und Exponent beider Zahlen
2. Vergleichen der Exponenten
3. Angleichen der Exponenten
4. Anpassen der Mantisse der Zahl, deren Exponent bei der
Exponentenanpassung verändert wurde
5. Addition der Mantissen, ggf. Änderung des gemeinsamen Exponenten
(bei Überlauf der Mantisse)
6. Normalisierung des Ergebnisses (gleitendes Komma)
Beispiel: Die Eulersche Zahl e = 2.71828182846 ... ist Grenzwert der Zahlenfolge
a1 , a2 , a3 , .... an , ... mit an = (1 + 1/ n ) n
Es gilt an < an+1 (Monotonie !) und an < e für alle natürlichen Zahlen n.
Folglich erhält man (mathematisch betrachtet) mit wachsendem n einen
immer besseren Näherungswert für e .

(3) Textzeichentyp
char
reserviert (i.a.) 1 Byte = 8 Bit Speicherplatz für genau ein Zeichen
(Erinnerung: z.B. ASCII­Code stellt Zeichen auf 8 Bit dar)
ein erster abgeleiteter Variablentyp:
Zeichenkette Aufeinanderfolge von Zeichen (z.B. Wörter)
Deklaration:
dargestellt und gespeichert als
Feld des Typs char
anderer Name: string
dabei ist n die maximale Anzahl Zeichen, d.h. die Feldlänge
­ durch die Deklaration wird ein Block von n Byte Speicherplatz im
Arbeitspeicher reserviert.
­ Achtung! Der Name stringname enthält dabei die Speicheradresse, an der
die Zeichenkette im Arbeitspeicher beginnt (stringname ist ein sog. Zeiger)
­ Zugriff auf die Komponenten, also die einzelnen Zeichen durch
stringname[i]
wobei der Index i das i­1 . Zeichen der Zeichenkette bezeichnet, da in C die
Numerierung bei 0 beginnt!
z.B. char str[5]="INFO";
str
➘
I N F O \0
1012 1013 1014 1015 1016 1017 ...
str enthält die Adresse 1015
str[0] = 'I', str[1]='N' , ...
char stringname[n];
str[0] str[1] str[2] str[3] Endezeichen
­ gespeichert wird natürlich jedes Zeichen in seiner Binärdarstellung!

­ es muß stets ein Byte Platz für das Endezeichen eingerechnet werden,
sonst kann es zu Problemen führen
Erreichen des Endezeichens kann z.B. in einer Schleifenanweisung durch
i=0;
while (str[i]!=0)
{
}
tue etwas
i=i+1;
abgefragt werden.
­ Achtung! Zuweisung eines ganzen Wortes nur in der Deklaration erlaubt
danach nur noch Zugriff auf Einzelkomponenten möglich
(4) leerer Typ void
sinnvoll z.B. Für Funktionen ohne Ergebniswert (sog. Prozeduren oder Subroutinen)
aus diesen Grundtypen lassen sich dann beliebig komplexere Typen selbstdefinieren
(dazu mehr in der 4. Vorlesung)
3.3 Ausdrücke und Operatoren
Ein Ausdruck ist eine Aneinanderreihung von Zahlen, Strings und Operatoren, die sich zu
einem Wert auflösen lassen, sprich: eine mehr oder weniger komplexe Rechenvorschrift
⇨Ausdrücke können über Operatoren miteinander verknüpft werden
⇨Ausdrücke können Variablen zugewiesen werden

Operatoren:
z.B.:
es gibt grundsätzlich unäre, binäre und terniäre Operatoren
(1) unäre Operatoren: (in C) Inkrementoperator ++ausdruck
ausdruck++
Dekrementoperator ­­ausdruck
ausdruck­­
(2) binäre Operatoren: arithmetische Grundoperationen + , ­ , * , /
(3) terniäre Operatoren: eher selten
Zuweisung: (binärer Operator)
(in allen Programmiersprachen)
in C z.B. Ausdruck1 ? Ausdruck2 : Ausdruck3
ist Ausdruck 1 wahr so berechne Audruck2 sonst berechne Ausdruck3
­ eine Zuweisung ist selbst wieder ein Ausdruck
­ die Zuweisung hat den Wert, der der Variablen zugewiesen wird
Vergleiche und logische Operatoren
Vergleiche
Symbolik fürVergleiche in Programmiersprachen ähnlich der aus
der Mathematik bekannten:
< , >
≤ ... =
= ... == doppeltes Gleichheitszeichen, da '=' der Zuweisung entspricht
allgemein ist die Syntax:
­ liefert wieder einen Ausdruck
Variablenname = Ausdruck
Ausdruck Vergleichsoperator Ausdruck
­ dieser Ausdruck hat einen int­Wert, und zwar 0 , falls der Vergleich nicht zutrifft
1, falls der Vergleich zutrifft

Logische Operatoren
Anweisungen
Aussagenlogisches UND ODER VERNEINUNG
Symbolik: && || ! (in C)
­ liefert wieder einen Ausdruck
.and. .or. .not. (in FORTRAN)
& | ~ (in MATLAB)
­ dieser Ausdruck hat einen int­Wert, und zwar 0 , falls der Gesamtausdruck wahr
1, falls der Gesamtausdruck falsch ist
­ sind in der jeweiligen Programmiersprache erlaubte Ausdrücke, die zeilenweise in den
Programmen geschrieben werden (oder durch entsprechende Zeichen voneinander
abgegrenzt, z.B. ein Komma in FORTRAN oder in MATLAB)
­ möglicherweise prinzipiell durch ein Zeichen abgeschlossen werden
in C:
Priorität von Operatoren
Ausdruck logischer Operator Ausdruck
Ausdruck ;
(von höchster zu niedrigster Priorität)
Symbol Name/Bedeutung Assoziativität
-----------------------------------------------------------------
++ Erhöhung nach Auswertung von links nach rechts
-- Erniedrigung nach Auswertung
( ) Funktionsaufruf
[ ] Arrayelement
-> Zeiger auf Strukturfeld
. Felder einer Struktur oder Union
-----------------------------------------------------------------
++ Erhöhung vor Auswertung von rechts nach links
-- Erniedrigung vor Auswertung
! logisches NOT
- unäres Minus
+ unäres Plus
& Adresse von
* Dereferenzierung
sizeof Größe in Bytes
(type) Typumwandlung (cast)
-----------------------------------------------------------------
* Multiplikation von links nach rechts
/ Division

% Divisionsrest (modulo)
-----------------------------------------------------------------
+ Addition von links nach rechts
- Subtraktion
-----------------------------------------------------------------
< kleiner als von links nach rechts
größer als
>= größer oder gleich
-----------------------------------------------------------------
== gleich von links nach rechts
!= ungleich
-----------------------------------------------------------------
&& logisches AND von links nach rechts
-----------------------------------------------------------------
|| logisches OR von links nach rechts
-----------------------------------------------------------------
? : Bedingung von rechts nach links
-----------------------------------------------------------------
= Zuweisung von rechts nach links
*= zusammengesetzte Zuweisung
/=
%=
+=
-=
=
&=
^=
|=
-----------------------------------------------------------------
, Komma-Operator von links nach rechts
-----------------------------------------------------------------
Typumwandlung
nötig, falls in einer Operation Operanden verschiedenen Typs beteiligt sind
● implizite Typumwandlung: durch den Compiler
z.B. int i=1, k=3;
float x;
x = i*k; int*int liefert int, in der Zuweisung Umwandlung intfloat
● explizite Typumwandlung: durch einen cast­Operator
z.B. float y = 6.78;
i = 3 + (int) y;