Wirtschaftsinformatik I
Werbung
WIRTSCHAFTSINFORMATIK I
Wintersemester 2006/2007
Autor: Klaus-Dieter Hutter
Stand: 05.12.2006
Wirtschaftsinformatik.doc
Erstellt von Klaus-Dieter Hutter
Seite 1 von 38
Stand: 05.12.2006
1 Inhaltsverzeichnis
1
Inhaltsverzeichnis................................................................................................................ 2
2
Übung: Beschreibung eines Radwechsels.......................................................................... 4
3
Begrifflichkeiten.................................................................................................................. 4
4
Algorithmus ......................................................................................................................... 5
4.1
5
Eigenschaften von Algorithmen.............................................................................................5
Turing-Maschine................................................................................................................. 9
5.1
Operationales Maschinenmodell .........................................................................................12
5.1.1
Drei-Adress-Befehl .......................................................................................................................... 13
5.1.2
Sprungbefehle .................................................................................................................................. 15
5.1.3
Spracherweiterung............................................................................................................................ 16
5.1.3.1
Indizierte Adressierung........................................................................................................... 16
6
Aufgaben eines Compilers ................................................................................................ 16
6.1
Höhere Programmiersprachen ............................................................................................16
6.2
Sprachmerkmale (Semiotik) ................................................................................................17
6.3
Objektsprache .......................................................................................................................17
6.4
Metasprachen ........................................................................................................................17
6.5
Bachus-Naur-Form (BNF) ...................................................................................................18
6.5.1
Wertebereich des Bezeichners.......................................................................................................... 18
6.5.1.1
Metadefinition für die Variablendeklaration in MODULA2 .................................................. 18
6.6
Erweiterter BNF....................................................................................................................18
6.7
Semantik von Programmiersprachen .................................................................................19
6.7.1
6.7.2
6.7.3
6.7.4
Übersetzer-Semantik ........................................................................................................................ 19
Operationale Semantik ..................................................................................................................... 19
Denotationale (funktionale) Semantik.............................................................................................. 20
axiomatische Semantik..................................................................................................................... 20
7
Möglichkeiten der Darstellung von Programmabläufen in der imperativen
Programmierung ....................................................................................................................... 20
7.1
7.1.1
7.1.2
7.1.3
7.1.4
7.1.5
7.2
7.2.1
7.2.2
7.2.3
7.3
Programmablaufpläne..........................................................................................................20
Aktion (Operation, Anweisung, Ein-/Ausgabe,….) ......................................................................... 20
Ablauf / Zusammenführung ............................................................................................................. 21
Verzweigung .................................................................................................................................... 21
Anfang / Ende .................................................................................................................................. 21
Übergangstellen................................................................................................................................ 21
Struktogramme (Nassi-Schneydermann) ...........................................................................21
Strukturblock (Anweisungen) .......................................................................................................... 21
Schleifen........................................................................................................................................... 22
Verzweigung .................................................................................................................................... 22
Pseudocode.............................................................................................................................22
Wirtschaftsinformatik.doc
Erstellt von Klaus-Dieter Hutter
Seite 2 von 38
Stand: 05.12.2006
7.4
Aufgabe „Darstellung Programmabläufe“ .........................................................................23
7.4.1
Lösung Struktogramm...................................................................................................................... 23
7.4.2
Lösung Programmablaufplan ........................................................................................................... 24
7.4.3
Lösung Pseudocode.......................................................................................................................... 24
7.4.4
Musterlösungen ................................................................................................................................ 25
7.4.4.1
Programmablaufplan............................................................................................................... 25
7.4.4.2
Struktogramm ......................................................................................................................... 26
7.4.4.3
Pseudocode ............................................................................................................................. 26
7.5
7.5.1
7.5.2
7.5.3
8
Vorteile / Nachteile Darstellung Programmabläufe...........................................................26
Programmablaufplan ........................................................................................................................ 26
Struktogramm................................................................................................................................... 27
Pseudocode....................................................................................................................................... 27
Konzepte imperativer Programmierung ........................................................................... 27
8.1
Aufgaben von Datentypen ....................................................................................................27
8.2
skalare Datentypen ...............................................................................................................27
8.3
strukturierte Datentypen......................................................................................................27
8.3.1
Skalare Datentypen .......................................................................................................................... 27
8.3.1.1
Der Datentyp BOOLEAN....................................................................................................... 27
8.3.1.1.1 Beispiel (MODULA2) ....................................................................................................... 28
8.3.1.2
Der Datentyp CARDINAL und INTEGER ............................................................................ 28
8.3.1.3
Der Datentyp REAL ............................................................................................................... 28
8.3.1.4
Der Datentyp CHAR............................................................................................................... 29
8.3.1.5
Aufzählungstypen ................................................................................................................... 29
8.3.2
Statisch strukturierte Datentypen ..................................................................................................... 30
8.3.2.1
Zugriffsart auf die Komponenten ........................................................................................... 30
8.3.2.2
Der Datentyp ARRAY............................................................................................................ 30
8.3.2.3
Der Datentyp RECORD ......................................................................................................... 31
8.3.2.3.1 Übung ................................................................................................................................ 31
8.3.2.4
Der Datetyp SET..................................................................................................................... 31
8.3.3
Dynamische strukturierte Datentypen .............................................................................................. 32
8.3.3.1
Der Datentyp SEQUENZ........................................................................................................ 32
8.3.3.1.1 Beispiel Datentyp SEQUENZ............................................................................................ 34
8.3.3.2
Der Datentyp POINTER......................................................................................................... 35
8.3.3.2.1 Das Pointer-Konzept.......................................................................................................... 35
8.3.3.2.2 Beispiel POINTER in PASCAL ........................................................................................ 36
8.3.3.2.3 Operatorbaum .................................................................................................................... 38
Wirtschaftsinformatik.doc
Erstellt von Klaus-Dieter Hutter
Seite 3 von 38
Stand: 05.12.2006
2 Übung: Beschreibung eines Radwechsels
1.
2.
3.
4.
5.
6.
7.
8.
Radmuttern mit Radkreuz leicht lösen
Auto mittels Wagenheber anheben, bis Rad keinen Bodenkontakt mehr hat
Radmuttern vollständig abschrauben
Rad abnehmen
Ersatzrad aufsetzen
Radmuttern so weit wie möglich – überkreuz – anschrauben
Auto mittels Wagenheber komplett ablassen
Radmuttern vollständig anziehen
3 Begrifflichkeiten
System:
Ein System ist eine räumlich abgeschlossene, logisch zusammenhängende und
zeitlich begrenzte Einheit, die voneinander abhängende Komponenten umfasst.
Modell: Bildung von Modellen
• Reduzierung auf relevante Merkmale
• Diskussion des Systems erfolgt also im Merkmalraum eines Modells
Ein Modell ist eine Zusammenfassung von Merkmalen eines realen oder künstlichen Systems
sowie eine Festlegung der Beziehungen zwischen diesen Merkmalen, d.h. eine Abstraktion
eines realen Systems durch Verzicht auf unwesentliche Merkmale.
Realität
Abstraktion
• System
Modell
• Merkmal
Attribut
• Merkmalausprägung
Wert
• Funktionalitäten
Methoden
Zustand: Ein Zustand ist somit die Belegung der Attribute eines Modells mit konkreten
Werten.
Das Wissen über den Zustand eines Systems wird als Information bezeichnet.
Beispiel:
Daten
Information
Wissen
Syntaktik
Semantik
Analogie anwenden
Zeichen
Bedeutung
Schlussfolgerung
rot, grün, gelb
Lampen einer Ampel
fahre ich 50km/h, habe ich
grüne Welle
Nachricht: wertfreie Übermittlung von Daten
Zeichencode dient zur Darstellung von Zeichen (ASCII, Unicode)
Dualzahl-Darstellung:
für N=5 gilt
positive Zahl
z = entsprechende Dualzahl
negative Zahl
–z = 2N – z (Zweierkomplement)
z.B.
-5 = 25 -5 = 27 (mit führender 1 für negative Zahlen)
Bsp:
3
00011
+ (-7)
11001
-4
11100
Wirtschaftsinformatik.doc
Erstellt von Klaus-Dieter Hutter
Seite 4 von 38
Stand: 05.12.2006
4 Algorithmus
Algorithmen sind sinnvolle Zustandsänderungen von Werten in Modellen
Im Rechner sind eigentlich nur Daten enthalten in Form von Ziffern, Zeichen eines Alphabets.
Der Algorithmus „haucht“ der Maschine pseudointelligentes Verhalten ein.
Bsp.:
15 / 3 => 5
„cat“ => „Katze“
„:-)“ => ☺
Rechnen in einem Computer ist somit das Manipulieren von Daten.
Merksatz:
Einen Algorithmus nennt man abstrakt, wenn er prinzipiell eine nicht beschränkte Klasse von
Problemen löst, z.B. die Multiplikation beliebiger ganzer Zahlen.
4.1 Eigenschaften von Algorithmen
•
•
•
•
•
•
•
•
sie müssen konkret beschrieben sein, einen endlichen Umfang haben
dürfen zur Laufzeit nur eine endliche Menge von Werten benutzen
muss in endlicher Zeit terminieren
endet ein Algorithmus bei gleichem Input stets mit gleichem Ergebnis, dann heißt er
determiniert (funktional)
liefert ein Algorithmus unterschiedliche Ergebnisse, nennt man ihn zufällig oder auch
randomisiert
suboptimale Algorithmen nennt man solche Berechnungen, die vor dem Optimum
stoppen, z.B. weil das Laufzeitverhalten sonst zu lange ist (Bsp.: Berechnung der Zahl
Pi)
ein deterministischer Algorithmus wird im gleichen Zustand stets auf die gleiche Weise
fortgeführt, ist also immer determiniert
liefern zwei verschiedene Algorithmen bei gleichen Eingaben stets die gleichen
Ergebnisse, so nennt man sie äquivalent
Beispiel:
Namensuche im Telefonbuch
- Suche nach Index
- sequentiell
- „divide and conquer“
(Buch in der Mitte aufschlagen, nach rechts
oder links weitersuchen, wieder die Mitte
aufschlagen usw.)
Die Laufzeit vieler Algorithmen hängt vom Umfang des Problems ab, welches zu lösen ist. In
diesem Zusammenhang spricht man von der Komplexität eines Algorithmus
nicht berechenbare Algorithmen: Erreichbarkeitsproblem
Äquivalenzproblem
Es gibt auch eine Klasse von Problemen, die nicht lösbar sind, z.B. Berechnung Zahl Pi
(grundsätzlich sind die Probleme aber berechenbar)
Die Ausführgeschwindigkeit eines Programmes wird auch als Komplexität bezeichnet.
Wirtschaftsinformatik.doc
Erstellt von Klaus-Dieter Hutter
Seite 5 von 38
Stand: 05.12.2006
Ein endlich deterministischer Automat
• ist ein mathematisches Modell
• Merkmale können verschiedene Ausprägungen/Werte annehmen
• endliche Automaten haben i.d.R. nur ein Merkmal
• die verschiedenen Werte der Attribute, die so ein Modell haben kann, werden als
Zustände bezeichnet
Graphische Notation zur Beschreibung eines Automaten:
• Modell befindet sich in einem bestimmten Zustand
• reagiert auf Ereignisse
• Modell reagiert mit Ausgabe
• es vollziehen sich Änderungen bei den Zuständen des Automaten
Endlicher Automat
E, A
0
1
N, U
4
E, A
E, 0
2
3
D, T
T, T
Abbildung 1 Endlicher Automat
Kreise stellen Zustände dar, Pfeile symbolisieren Übergänge zwischen den Zuständen, das
Zeichenpaar (A,Z): erstes Zeichen = Eingabewert (extern)
zweites Zeichen = Ausgabewert, verbunden mit Zustandswechsel
Anfangszustand
Endzustand
z.B.:Zeichenkette Eingabe: ENTE
Zeichenkette Ausgabe: AUTO
Wirtschaftsinformatik.doc
Erstellt von Klaus-Dieter Hutter
Seite 6 von 38
Stand: 05.12.2006
Formal lässt sich ein Automat durch ein 6-er Tupel definieren
A = ( Z = { 0, 1, 2, 3, 4 },
Ein = { A, ……., Z },
Aus = { A, …...., Z },
Ü = { ( 0, E, A, 1 ), ( 1, N, U, 2 ), ( 2, E, A, 1 ), ( 2, D, T, 3 ), ( 2, T, T, 3 ), (3, E, O, 4 ) },
Anf = 0,
End = 4)
T, T
E, A
N, U
0
3
2
E, 0
1
E, A
4
E, 0
R, T
5
6
D, 0
Abbildung 2 Aufgabe Deterministischer Automat
Aufgabe:
•
•
Ein: ERDE
Aus: ATOO
Ein: ENERDE
Aus: AUATOO
Definitionen
• Ein Automat heißt endlich, wenn er endlich viele Zustände besitzt und das
Eingabealphabet endlich ist.
•
Ein Automat heißt deterministisch, wenn in keinem Zustand zu einer Eingabe mehr als
ein Folgezustand festgelegt ist
•
Ein Automat heißt unvollständig, wenn zu einem Zustand und möglichen Eingabewert
kein Nachfolgezustand definiert ist
•
Ein Automat heißt indeterministisch, wenn zu einem Zustand und möglichen
Eingabewert mehrere Nachfolgezustände definiert sind
Wirtschaftsinformatik.doc
Erstellt von Klaus-Dieter Hutter
Seite 7 von 38
Stand: 05.12.2006
T, T
E, A
N, U
0
3
2
E, 0
1
E, A
4
E, 0
R, T
5
6
D, 0
D, T
Abbildung 3 Unvollständiger Automat
T, T
E, A
N, U
0
3
2
E, 0
1
E, A
4
E, A
E, 0
R, T
5
6
D, 0
Abbildung 4 Indeterministischer Automat
Wirtschaftsinformatik.doc
Erstellt von Klaus-Dieter Hutter
Seite 8 von 38
Stand: 05.12.2006
5 Turing-Maschine
Die Turing-Maschine ist ein
Berechnungsmodell
Automat
Speicherband
Ein Berechnungsschritt besteht aus
Wert aus einem Speicher lesen
in Abhängigkeit vom Automatenzustand einen neuen Wert schreiben
Schreib-/Lesekopf nach links oder rechts bewegen
1
k, &, R
Schreiben von
"&"
0
Lesen von
"k"
v, %, L
2
Schreib-/Lesekopf
L
...
N
M
R
L
K
V
D
1
2
...
Abbildung 5 Turing-Maschine
Bewegungsrichtung
k, &, R
Eingabe
Ausgabe
Abbildung 6 Legende Turing-Maschine
Wirtschaftsinformatik.doc
Erstellt von Klaus-Dieter Hutter
Seite 9 von 38
Stand: 05.12.2006
0, ., L
., ., L
3
8
Stop
0, 1, L
0, 0, R
1, 1, R
Start
., ., R
0
1, 1, L
0, 0, L
., ., L
1, 1, R
1
2
., ., L
1, 0, L
4
5
., ., L
0, 0, R
., ., R
0, 1, R
7
6
., 1, R
1, 0, L
0, 0, R
1, 1, R
Abbildung 7 Übung Turing-Maschine
.
1
1
2
2
2
4
5
5
5
6
6
7
7
1
2
2
2
4
4
5
5
6
7
1
Wirtschaftsinformatik.doc
Erstellt von Klaus-Dieter Hutter
0
0
1
.
.
1
1
1
.
1
1
1
.
0
1
1
.
0
1
0
.
1
1
0
.
1
0
1
.
1
.
Seite 10 von 38
Stand: 05.12.2006
2
2
2
4
5
5
5
6
6
6
7
7
7
1
2
2
2
4
4
4
5
6
7
1
1
2
2
4
5
5
5
6
6
7
7
1
1
2
2
4
4
5
Wirtschaftsinformatik.doc
Erstellt von Klaus-Dieter Hutter
1
0
1
.
0
0
1
.
0
0
1
0
0
.
1
0
0
.
1
1
0
.
1
.
0
1
1
.
0
1
0
.
0
1
0
.
0
1
0
.
1
0
Seite 11 von 38
Stand: 05.12.2006
0
5
6
7
1
1
1
2
4
5
5
5
6
6
6
6
6
7
7
7
7
7
1
1
1
1
3
3
3
3
8
.
1
.
0
0
1
.
0
0
0
.
0
0
0
0
1
0
0
0
0
.
0
0
0
.
.
.
.
1
0
0
0
0
.
.
.
.
.
.
Schlussfolgerung:
Zu jedem berechenbaren Problem gibt es eine konstruierbare Turingmaschine, die das Problem
löst.
5.1 Operationales Maschinenmodell
-
Speicher (Band) aus linearen Folgen von Zellen von der Nummer 0 bis 220
- Werte dieser Zellen können sein
+ Anweisungen (instructions / Befehle)
+ Daten
Programm (Algorithmus) besteht aus mehreren Befehlen. Befehle manipulieren Daten,
manipulierte Daten werden im Speicher abgelegt.
Ein Programm wird während seiner Abarbeitung als Prozess bezeichnet, daher stellt ein
Prozess eine Abfolge von Befehlen auf Daten dar.
Wirtschaftsinformatik.doc
Erstellt von Klaus-Dieter Hutter
Seite 12 von 38
Stand: 05.12.2006
Befehlszähler legt Reihenfolge der Befehle fest (gibt die Nummer der Zellen an, die den als
nächsten ausführbaren Befehl enthält).
Die Nummer einer Zelle bezeichnet man als Adresse, die Zelle heißt auch Speicherplatz.
In der Regel wird der Befehlszähler um eins erhöht, aber es gibt auch Befehle, in der der
nächste Befehl zur Ausführung steht (Sprungbefehle – goto-Befehle).
5.1.1 Drei-Adress-Befehl
enthält
- zwei Operanden (Werte)
- einen Verknüpfungsoperator (Operator)
- eine Adresse für Ergebnisspeicherung (Adresse)
Adresse
:=
Wert
Operator
Wert
}
Zuweisung /
Wertzuweisung /
Assignment
Adresse
Wert der Tabelle
Befehlszähler
0
000
adr104 : = val101 + val102
1
001
adr101 : = val101 + con9
2
002
adr104 : = val101 + val102
3
:
100
2
2
2
2
101
4
4
13
13
102
5
5
5
103
7
7
7
7
104
8
9
9
18
0
1
2
3
}
5
adr… ::=
gibt Adresse an, d.h. die Nummer gibt den Speicherplatz an
val… ::=
bedeutet, dass der Wert (Value), der unter der Adresse mit der Nummer
gespeichert ist, gemeint ist
con… ::=
Konstante Ziffer (Zeichen) repräsentiert den Wert
Wirtschaftsinformatik.doc
Erstellt von Klaus-Dieter Hutter
Seite 13 von 38
Stand: 05.12.2006
Adresse
Wert der Tabelle
Befehlszähler
0
000
adrSumme : = valBetrag + val Wert
1
001
adrBetrag : = valBetrag + con9
2
002
adrSumme : = valBetrag + valWert
3
:
Zins
Anzahl
2
2
2
2
Betrag
4
4
13
13
Wert
5
5
5
Mittel
7
7
7
7
Summe
8
9
9
18
0
1
2
3
5
Kapitel * Zinssatz * Tage
100 * 360
=
Kapital
Zinssatz
Tage
}
1000
4%
100
Adresse
Wert der Tabelle
Befehlszähler
0
000
adrNenner : = con100 * con360
1
001
adrZaehler : = valKapital * valZinssatz
2
002
adrZaehler : = valZaehler * valTage
3
003
adrZins
4
:= valZaehler / valNenner
:
Zins
0
0
0
0
11,11
Kapital
1000
1000
1000
1000
1000
Zinssatz
4
4
4
4
4
Tage
100
100
100
100
100
Nenner
0
36000
36000
36000
36000
Zaehler
0
400000
400000
3
4
0
Wirtschaftsinformatik.doc
Erstellt von Klaus-Dieter Hutter
}
4000
1
2
Seite 14 von 38
Stand: 05.12.2006
5.1.2 Sprungbefehle
Vergleichsoperator
goto
}
}
wenn
then
}
valInhalt > con10
}
if
adrMaske
dann
Sprung
Zielmarke
Beispiel
000
001
002
003
004
005
006
:
Fak
Hilf
N
Fak
Hilf
N
Fak
Hilf
N
adrFak :=
con1
adrHilf:=
con2
if valHilf
>
valN then goto adr006
adrFak :=
valHilf * valFak
adrHilf:=
valHilf + con1
goto adr002
nächster Befehl
:
1
5
5
1
2
5
0
1
2
3
4
5
6
7
8
6
4
5
6
4
5
6
4
5
24
4
5
24
5
5
24
5
5
24
5
5
120
5
5
120
6
5
9
10
11
12
13
14
15
16
17
120
6
5
}
1
2
5
2
2
5
2
3
5
2
3
5
2
3
5
6
3
5
Sprung in adr006
18
Fakultät 5
Wirtschaftsinformatik.doc
Erstellt von Klaus-Dieter Hutter
Seite 15 von 38
Stand: 05.12.2006
5.1.3 Spracherweiterung
valvalName
000
001
002
:
350
:=
adrKarl
adrPeter
adrSusi
:
Notationserweiterung, es geht um den Wert, der unter der Adresse steht,
die wir an der Stelle “valname” finden.
:=
:=
:=
„indirekte Adressierung“
conMichel
valMichel
valvalMichel
Starte
Starte
Starte
Starte
Karl
0
Michel
Michel
Michel
Peter
0
0
350
350
Susi
0
0
0
Starte
350
350
350
350
0
1
2
3
Michel
Auflösung von rechts nach
links:
valvalMichel ^= val350
^= Starte
5.1.3.1 Indizierte Adressierung
Bei dieser Notationserweiterung wird die Adresse nicht direkt oder indirekt angegeben,
sondern durch eine Operation errechnet;
wobei die Operanden der Operation wiederum Adressen oder Konstanten sein können.
Beispiel:
adr [ valPeter + valSusi ]
val [ valKarl + valMichel ]
val [ con350 + valKarl ]
==>
==>
==>
adr0
Starte
Starte
6 Aufgaben eines Compilers
a.) lexikalische Analyse:
Das Übersetzungsprogramm prüft,, ob die vorliegenden
Zeichenketten Begriffe wiedergeben, die der Compiler kennt,
sogenannte wohlgeformte Wörter und stellt sie in Zeichen dar,
die von der Maschine verarbeitet werden können.
b.) syntaktische Analyse: Hier werden die sogenannten „Rechtschreibregeln“
(Grammatik) der Maschinensprache geprüft. Sind die Begriffe
in einer Reihenfolge aufgeführt, die nach der
Maschinensprache zulässig sind und sind an fest
vorgeschriebenen Stellen definierte Zeichen gesetzt, im
gewissen Sinn die Interpunktion der Maschinensprache.
c.) semantische Analyse: Hier wird geprüft, ob die unter a.) eingeführten Variablen und
deren Werte in der richtigen Weise ( b.) ) eingeführt und
richtig verwendet werden.
6.1 Höhere Programmiersprachen
kompakt, problemorientiert, portabel
Programmiersprache Schnittstelle zwischen Rechner und Mensch
Wirtschaftsinformatik.doc
Erstellt von Klaus-Dieter Hutter
Seite 16 von 38
Stand: 05.12.2006
6.2 Sprachmerkmale (Semiotik)
gültig für künstliche und natürliche Sprachen
a.) Syntax (Grammatik)
Menge von Vorschriften und Regeln
Aufbau von Wörtern, Sätzen und Programmen
b.) Semantik
Bedeutung eines syntaktisch korrekten Satzes oder Programmes
syntaktische Korrektheit ist notwendig, aber nicht hinreichende Bedingung für
semantisch eindeutige Interpretation
c.) Pragmatik
Zweckmäßigkeit unter Berücksichtigung der Umwelt
6.3 Objektsprache
Programm: Aneinanderkettung oder –reihung einzelner Zeichen, d.h. ein Wort über
einem zugrunde liegenden Alphabet
Schlüsselwörter:
einigen Zeichenketten kommen eine besondere Bedeutung zu und
sie dürfen nur in diesem Sinn verwendet werden, sogenannte
atomare Einheiten.
Terminalsymbole:
Alphabet: geordneter, endlicher, nichtleerer Zeichenvorrat
Schlüsselwörter: endliche Menge von bestimmten Zeichen bzw. Wörtern,
z.B.
BEGIN
;
END
IF
WHILE
diese beiden Mengen sind disjunkt (
Schnittmenge ist leer)
6.4 Metasprachen
Die Metasprache beschreibt nun, wie diese Terminalsymbole zu größeren Einheiten
aneinandergereiht werden dürfen.
Metavariablen:
(Nonterminalsymbole). Sie werden benötigt, um von konkreten
Terminalsymbolen zu abstrahieren und sie in „Klassen“ von
Zeichenketten oder sonst irgendwie zusammengehörig zu
beschreiben, z.B. „if-Anweisung“, „Variablenvereinbarung“
Metaausdrücke:
sind größere Einheiten, die Terminalsymbole und Metavariablen
verbinden. Dargestellt wird die Verknüpfung durchh Metasymbole
Metadefinitionen bestehen aus
Metavariablen und
Metaausdrücke
Wirtschaftsinformatik.doc
Erstellt von Klaus-Dieter Hutter
Seite 17 von 38
Stand: 05.12.2006
6.5 Bachus-Naur-Form (BNF)
}
}
Metadefinition für die Metavariablen <Bezeichner>, <Buchstabe> und <Ziffer> in
MODULA2.
<Bezeichner> ::= <Buchstabe> | <Bezeichner><Buchstabe> | <Bezeichner><Ziffer>
<Buchstabe> ::= A | B | C | D | E | …….. X | Y | Z
a | b | c | d | e | ………. x | y | z
<Ziffer>
::=
1|2|3|4|5|6|7|8|9|0
Metavariable
Definitionssymbol
Metaausdruck
rekursiver Aufbau der Definitionen
Metasymbole: | = Auswahlsymbol (logisches oder)
::=
Definitionssymbol
<>
}
Beispiel:
Klaus, KL4711 sind gültige Bezeichner
PE&RL, 94KL sind KEINE gültigen Bezeichner
6.5.1 Wertebereich des Bezeichners
Alle endlichen, nichtleeren Zeichenketten über die Vereinigungsmenge { A, B, C, ……., Z } {
1, 2, 3, ….., 9, 0 }, die mit einem Buchstaben beginnen.
6.5.1.1 Metadefinition für die Variablendeklaration in MODULA2
<VarVereinb>
<Vereinbarungen>
<Vereinbarung>
<Typ>
Beispiel:
VAR
::=
::=
::=
::=
VAR<Vereinbarungen>
: | <Vereinbarung><Vereinbarungen>
<Bezeichnerliste>:<Typ>;
INTEGER | CARDINAL | REAL | BOOLEAN | … weitere Typen
Alter : INTEGER;
i, j, k : REAL;
}
Bereich Variablendeklaration,
wird abgeschlossen durch nächstes
Schlüsselwort (hier: BEGIN)
BEGIN
6.6 Erweiterter BNF
[ Metaausdruck ]
Metaausdruck in eckigen Klammern bezeichnet optionale Zeichenketten,
die auch wegfallen können
{ Metaausdruck }
Metaausdruck in geschweiften Klammern bezeichnet eine beliebige
Wiederholung der Zeichenketten (Iteration)
{ Metaausdruck }ab Wiederholung mind. a-mal, höchstens b-mal, b = *
Beispiel:
<Bezeichner>
::=
nach oben offen
<Buchstabe> { <Buchstabe> | <Ziffer> }
Die BNF und EBNF stellen Grammatiken dar, mit deren Hilfe z.B. die Syntax einer
Programmiersprache beschrieben werden kann.
Wirtschaftsinformatik.doc
Erstellt von Klaus-Dieter Hutter
Seite 18 von 38
Stand: 05.12.2006
Solche Grammatiken können formal wie folgt definiert werden:
Eine Grammatik ist ein TUPEL G = { N, T, P, S }, wobei
N = die Menge der Nichtterminalsymbole
T = Menge der Terminalsymbole
P = Menge der Produktionen / Regeln
S = Startsymbol
ist.
Dies sind sogenannte kontexfreie Grammatiken, mit denen man kontexfreie Sprachen erzeugen
kann.
Sind die rechten Seiten der Produktionsregeln so beschränkt, dass dort nur EIN
Nichtterminalsymbol gefolgt von einem Terminalsymbol stehen darf, so spricht man von
regulären Grammatiken.
6.7 Semantik von Programmiersprachen
6.7.1 Übersetzer-Semantik
Rückführung auf bekannte Programmiersprache.
Verfahren: Die Bedeutung einer Sprache wird Wort für Wort, Ausdruck für
Ausdruck auf die Bedeutung einer bekannten Sprache zurückgeführt.
Abstraktion: Für die tatsächliche Übersetzung eines Programms wird man jedoch
nicht eine ebenso komplexe Programmiersprache (z.B. von C++ nach
Delphi) wählen, sondern auf eine Maschinensprache (Assembler)
zurückgreifen.
Nachteile:
Ein wenig zirkulär ist dieses Verfahren: es setzt die Semantikdefinition
der Übersetzersprache voraus. Als nachteilig kann sich auch
Orientierung an einem konkreten Maschinenmodell erweisen.
Analogie:
Das klassische Übersetzen z.B. vom Englischen ins Deutsche
verdeutlicht diesen Ansatz. Besondere Schwierigkeiten bereiten dabei
Wörter und Strukturen, für die es keine direkte Entsprechung gibt.
Solche Konstrukte müssten umschrieben werden.
In der Abstraktion müssten Sprachausdrücke jedoch in semantische
Primitiva übersetzt werden; diese unterliegen dann einer ganz
bestimmten Modellierung der Welt (Ontologie)
6.7.2 Operationale Semantik
Darstellung der Zustandsänderungen mit Hilfe von semantischen Funktionen
Sie ist eine Technik der Informatik, um die Bedeutung beziehungsweise die Semantik von
Computerprogrammen zu beschreiben. Sie beschreibt die Wirkung von Programmen als
schrittweise Zustandsänderung einer abstrakten Maschine. Operationale Semantik wird
verwendet, um Eigenschaften über einzelne Programme nachzuweisen oder Programme
zueinander in Beziehung zu setzen.
Zentral für die operationale Semantik ist der Begriff des Programmzustands. Ein Zustand
beschreibt dabei (in den meisten Fällen) eine Belegung der Programmvariablen sowie eine
Position im Programm. Des weiteren wird definiert, wann und wie sich Zustände ändern. Dies
geschieht entweder mit Hilfe einer Zustandsübergangsfunktion oder durch sogenannte
Inferenzregeln (also regelbasiert). Zustandsübergangsfunktion bzw. Inferenzregeln definieren
einen Interpreter.
Wirtschaftsinformatik.doc
Erstellt von Klaus-Dieter Hutter
Seite 19 von 38
Stand: 05.12.2006
Um mit der operationalen Semantik eines Programms zu arbeiten, wird in der Regel ein Stück
weit vom Originalprogramm abstrahiert. Es wird ein abstraktes Programm aufgestellt, das
äquivalent zum Original (dem konkreten Programm) ist und das durch einen abstrakten
Interpreter ausgeführt werden kann. Die Wirkungen, die dieses abstrakte Programm auf die
Zustände der abstrakten Maschine erzeugt, sind dann äquivalent zu den Zuständen, die erhalten
werden, wenn das konkrete Programm ausgeführt wird.
Beispiele für die Verwendung von operationaler Semantik sind die Semantikspezifikationen
von Algol 60, PL/I oder VDL.
6.7.3 Denotationale (funktionale) Semantik
Darstellung der Zustandsänderungen mit Hilfe von Konfigurationen.
Auch Funktionensemantik genannt; sie beschreibt die Wirkungsweise eines Programms als
partielle Abbildung eines Speicherzustandes in einen anderen. Die Regeln des Kalküls legen
(induktiv) fest, wie die Funktion zu einem Programm gebildet wird.
6.7.4 axiomatische Semantik
Darstellung der Auswirkungen von Zustandsänderungen auf die Eigenschaften von Zuständen.
Sie beschreibt die Bedeutung von Programmen durch Schluusregeln, die es erlauben von einer
gewünschten Eigenschaft der Eingabe auf Eigenschaften der Ausgabe zu schließen. Dabei
abstrahiert die axiomatische Semantik weiter als die denotationale Semantik. Es werden keine
konkreten Speicher transformiert, sondern nur logische Aussagen über Speicher, genauer
gesagt über Werte von Programmvariablen in ihnen. Die axiomatische Semantik entspricht der
Sicht des Programmierers. Sie scheint im Gegensatz zur operaationalen Semantik nur für
imperative Sprachen geeignet zu sein. Es existieren zwei Hauptausprägungen, der
Hoare-Kalkül und der
wp-Kalkül.
7 Möglichkeiten der Darstellung von Programmabläufen
in der imperativen Programmierung
befehls-/ablauforientiert
7.1 Programmablaufpläne
7.1.1 Aktion (Operation, Anweisung, Ein-/Ausgabe,….)
Aktion
Wirtschaftsinformatik.doc
Erstellt von Klaus-Dieter Hutter
Seite 20 von 38
Stand: 05.12.2006
7.1.2 Ablauf / Zusammenführung
7.1.3 Verzweigung
Ja
Bedingung
Nein
7.1.4 Anfang / Ende
Start
Stop
7.1.5 Übergangstellen
A
A
In DIN-Norm werden Symbole festgelegt.
7.2 Struktogramme (Nassi-Schneydermann)
7.2.1 Strukturblock (Anweisungen)
elementarer Strukturblock
Anweisung
Wirtschaftsinformatik.doc
Erstellt von Klaus-Dieter Hutter
Seite 21 von 38
Stand: 05.12.2006
Sequenz
f1
f2
f3
7.2.2 Schleifen
kopfgesteuerte Schleifen
while b do
f1
fußgesteuerte Schleifen (mind. 1x)
f1
REPEAT UNTIL b
7.2.3 Verzweigung
bedingte Anweisung
Bedingung
T
f1
F
f2
Fall- (case-) Anweisung
r=
1
2
3
4
f1
f2
f3
f4
5
f5
else
f6
7.3 Pseudocode
elementare Anweisungen
f1, f2, f3, f4, ……., fn
Wirtschaftsinformatik.doc
Erstellt von Klaus-Dieter Hutter
Seite 22 von 38
Stand: 05.12.2006
Sequenz
BEGIN
f1,
f2,
f3,
f4,
fn
END
Schleife
WHILE
DO
f
END
b
REPEAT f
UNTIL b
Verzweigung
IF
b
THEN
ELSE
END
f1
f2
7.4 Aufgabe „Darstellung Programmabläufe“
Suche in einer unsortierten Folge
Problem: - endliche, nicht leere Folge k1, k2, k3, …., kn von Schlüsselwerten
- einen Vergleichsewert k ε M
- Folgeglieder in beliebiger Reihenfolge
- Schlüsselwert kann mehrfach vorkommen
gesucht ist der Schlüsselwert, der am weitesten links in der Folge steht, der mit
k übereinstimmt
7.4.1 Lösung Struktogramm
Lese Element Folge
while k != Element Folge oder EOF
Lese nächstes
Element Folge
if EOF
J
Ausgabe EOF
Wirtschaftsinformatik.doc
Erstellt von Klaus-Dieter Hutter
N
Ausgabe Element
Seite 23 von 38
Stand: 05.12.2006
7.4.2 Lösung Programmablaufplan
Start
Lese Element Folge
Element Folge = k
oder EOF
Ausgabe Element
oder EOF
Stop
7.4.3 Lösung Pseudocode
BEGIN
Lese Element Folge
WHILE k != Element Folge oder EOF
DO
Lese nächstes Element Folge
END
Ausgabe Element Folge oder EOF
END
Wirtschaftsinformatik.doc
Erstellt von Klaus-Dieter Hutter
Seite 24 von 38
Stand: 05.12.2006
7.4.4 Musterlösungen
7.4.4.1 Programmablaufplan
Start
Eingabe k1, ...., kn, k
found ::= false
not found
und nicht alle
Elemente betrachtet
nehme nächstes
Element ki
found ::= ( ki = k )
found ?
Ausgabe: n + 1
Ausgabe: i
Stop
Wirtschaftsinformatik.doc
Erstellt von Klaus-Dieter Hutter
Seite 25 von 38
Stand: 05.12.2006
7.4.4.2 Struktogramm
Eingabe k1, ..... , kn, k
found ::= false
while (not found) und
"nicht alle Elemente betrachtet"
do
nehme nächstes Element ki
found ::= ( ki = k )
found ?
J
Ausgabe i
N
Ausgabe EOF
7.4.4.3 Pseudocode
BEGIN
Eingabe: k1, k2, ….., kn, k
found ::= FALSE;
WHILE NOT FOUND AND
„nicht alle Elemente betrachtet“
DO
nehme nächstes Element
found ::= (ki = k)
END
IF found
THEN Ausgabe i
ELSE Ausgabe n+1
END
END
7.5 Vorteile / Nachteile Darstellung Programmabläufe
7.5.1 Programmablaufplan
Vorteil:
-
Nachteil: -
durch graphische Visualisierung vor allem für Anfänger leicht verständlich
Darstellung beginnt auf hohem Abstraktionsniveau und kann durch weitere
Diagramme verfeinert werden
alle wesentlichen Ablaufstrukturen sind erkennbar und abbildbar
größere Diagramme können sehr schnell unübersichtlich werden
Verzweigungen und Zusammenführungen können beliebig kombiniert werden,
was zu einem unstrukturierten Diagrammablauf führen kann
Wirtschaftsinformatik.doc
Erstellt von Klaus-Dieter Hutter
Seite 26 von 38
Stand: 05.12.2006
7.5.2 Struktogramm
Vorteil:
-
Nachteil: -
alle wichtigen Ablaufstrukturen abbildbar
rekursive Definitionen der Strukturblöcke erlaubt
beliebige Sprünge sind nicht mehr möglich
größere Diagramme können sehr schnell unübersichtlich werden
Abhilfe: von hoher Abstraktionsebene immer mehr verfeinern
7.5.3 Pseudocode
evtl. Vor-/Nachteil:
keine graphische Darstellung
Nachteil: Sprungbefehle möglich
8 Konzepte imperativer Programmierung
Datentyp: -
bezeichnet den Wertebereich von Variablen
einzelne Werte heißen Konstanten
8.1 Aufgaben von Datentypen
-
zur Berechnung des benötigten Speicherbereichs durch den Computer
Zulässigkeit der Variablenverarbeitung
Verbesserung der Programmverständlichkeit
Speichern / Ablegenn von Werten
8.2 skalare Datentypen
-
wenn zuordbare Konstanten unteilbare Einheiten darstellen
Wertebereich mit totaler Ordnung (z.B. ein Wert ist größer als ein anderer, Alphabet: A
kommt vor B)
z.B. integer
8.3 strukturierte Datentypen
Zusammenfassung von Werten w1, …., wn aus beliebigen Typen als Wert w eines neues
Typs
w1, …., wn sind Komponenten von w; w nennt man strukturiert, wobei die
Komponenten wiederum aus strukturierten Typen bestehen kann.
Operationen: - ein Datentyp besteht aus dem Wertebereich und darauf definierten Operationen
8.3.1 Skalare Datentypen
8.3.1.1 Der Datentyp BOOLEAN
Wertebereich: { falsch, wahr }
Ordnung:
falsch < wahr
Operation: TRUE
FALSE
NOT
AND
OR
=
} 0-stelliger Operator, Konstante mit dem Namen „TRUE“
}
und „FALSE“
logisches NICHT ¬, unärer Operator
logisch UND ^
logisch ODER v
logisch Äquivalenz <==>
Definition: meistens vordefinierter Typ
Wirtschaftsinformatik.doc
Erstellt von Klaus-Dieter Hutter
Seite 27 von 38
Stand: 05.12.2006
8.3.1.1.1 Beispiel (MODULA2)
VAR Zaehler, Nenner : CARDINAL;
k, ok :
BOOLEAN;
BEGIN
ok := NOT k;
Nenner := 0;
END
8.3.1.2 Der Datentyp CARDINAL und INTEGER
Wertebereich:
Ordnung:
maschinenabhängige,endliche Teilmenge der mathematischen Wertebereiche
N0 (CARDINAL)
Z (INTEGER)
natürliche Ordnung
Operationen:
-
Addition (+)
Subtraktion (-)
Multiplikation (*)
=, <, >, Test auf Gleichheit / Ungleichheit
Vergleichsoperatoren
DIV
ganzzahlige Division
MOD Rest bei ganzzahliger Division
Definition: vordefinierter Typ
Beispiel
VAR n,m : INTEGER;
BEGIN
n := ( m + 17 ) MOD10;
END
8.3.1.3 Der Datentyp REAL
Wertebereich:
Ordnung:
Operationen:
maschinenabhängige, endliche Teilmenge der reellen Zahlen R
natürliche Ordnung
+
*
/
=, <, >
TRUNC Abschneiden der Stellen nach Dezimalpunkt
ROUND mathematisches Runden
SQRT
Quadratwurzel
Definition: bereits vordefiniert
Beispiel:
VAR x,y : REAL;
BEGIN
………
x = ( x + y ) / z;
………
END
Wirtschaftsinformatik.doc
Erstellt von Klaus-Dieter Hutter
Seite 28 von 38
Stand: 05.12.2006
8.3.1.4 Der Datentyp CHAR
Wertebereich: Zeichenvorrat des verwendeten Codes (ASCII, EBCDIC, UNICODE)
Ordnung:
abhängig vom verwendeten Code, dabei gilt immer:
„a“ < „b“ < ……… < „z“
„A“ < „B“ < …….. < „Z“
„0“ < „1“ < ………. < „9“
Diese Bereiche durchdringen sich nicht, z.B. keine Mischung von Groß- und Kleinbuchstaben.
Operationen:
ORD(c)
liefert die Ordnungszahl des Zeichens c
ORD: CHAR CARDINAL
CHR(i)
liefert mir das Zeichen mit der Ordnungszahl i
CHR: CARDINAL CHAR
Definition: bereits vordefiniert
Beispiel:
VAR c : CHAR;
BEGIN
…..
c := CHR(99)
…..
END
8.3.1.5 Aufzählungstypen
Wertebereich:
Menge der aufgeschriebenen Werte, z.B. Einschränkung bei Eingaben ( l =
ledig, v = verheiratet, g = geschieden etc.)
Ordnung: gemäß expliziter Reihenfolge der Aufführung, d.h. der Wert i kommt vor dem Wert
i+1
Operatoren:
<, >, !=, „vor“, „nach“, „ungleich“
INC(x) liefert den Wert, der in der Definition nach dem Wert x aufgeschrieben
wurde
DEC(x) liefert den entsprechenden Wert „vor“ x
Definition: mittels Konstruktoren “(“ und “)“
Einschluss in Klammern
Beispiel:
TYPE WoTag=(Mo, Di, Mi, Do, Fr, Sa, So)
VAR
Tag : WoTag;
frei : BOOLEAN;
BEGIN
…….
frei := ( Tag > Fr );
…….
END
Wirtschaftsinformatik.doc
Erstellt von Klaus-Dieter Hutter
Seite 29 von 38
Stand: 05.12.2006
aktuelle Schreibweise: „a“ ° „b“
Beispiel:
var_1 := „a“ + „b“;
var_2 := 4 + 10;
Zur Laufzeit hat Operator unterschiedliche Bedeutungen
Variablen müssen unterschiedlichen Typs sein
Operator ist überladen, kann unterschiedlich interpretiert werden
möglich: -
anhand des zugrundeliegenden Zeichenvorrats die Werte umrechnen, dann
addieren
Konkardination (Verkettung) beider Zeichenketten
-
8.3.2 Statisch strukturierte Datentypen
jedes Element setzt sich aus Werten anderer Typen zusammen
Struktur ist bereits vor der Übersetzung bekannt (Speicherplatz ist statisch reserviert
und nicht erst zur Programmlaufzeit, d.h. dynamisch)
Unterscheidung erfolgt aufgrund der Datentypen ihrer Komponenten
1.) alle beteiligten Typen der Komponenten sind vom selben Typ
- homogene, strukturierte Datentypen
- Beispiel: ARRAY, SET
2.) alle beteiligten Typen der Komponenten können von unterschiedlichen Typen sein
- inhomogene, strukturierte Datenytpen
- Beispiel: RECORD
8.3.2.1 Zugriffsart auf die Komponenten
a.) sequentieller Zugriff (entlang einer gegebenen Zeichenkette)
b.) direkter Zugriff (über Indexwert oder über Namen)
c.) Zugriff über Test auf Enthaltensein
8.3.2.2 Der Datentyp ARRAY
Komponentenfolge gleichen Typs (homogen)
statisch, wenn Anzahl der Komponenten vorher bekannt
dynamisch, wenn Anzahl der Komponenten zur Laufzeit änderbar
Wertebereich:
T x T x T x T x T x …..x T
homegenes, kartesisches Produkt n mal Typ T
Definition: mittels Konstruktor
„ARRAY[ IndexTyp ] OF T“
Zugriff:
über Indexwert im Array (direkter Zugriff)
Beispiel:
TYPE Vektor10=ARRAY[1..10] OF CARDINAL;
VAR
v : Vektor10;
BEGIN
……..
v[5] := 88;
……..
END
Wirtschaftsinformatik.doc
Erstellt von Klaus-Dieter Hutter
Seite 30 von 38
Stand: 05.12.2006
8.3.2.3 Der Datentyp RECORD
Komponentenfolge ungleichen Typs (inhomogen)
Wertebereich:
T1 x T2 x T3 x ….. x Tn
Ti unterschiedliche Typen inhomogenes kartesisches Produkt
Definition: mittels Konstruktion
„RECORD komponentDef END“
Zugriff:
Beispiel:
über den Namen (Direktzugriff)
RecordName, KomponentenName
TYPE Buch = RECORD
Autorname,
Autorvorname : ARRAY [1..20] OF CHAR;
Seite : CARDINAL;
Preis : REAL;
END;
VAR Exemplar : Buch;
BEGIN
……..
Exemplar.Preis := 10,50;
……..
END
8.3.2.3.1 Übung
1000 Visitenkarten (Firma, Name, Vorname, Telefon, Email, Straße, PLZ, Ort)
TYPE Visitenkarte = RECORD
Firma : ARRAY [1…30] OF CHAR;
Name : ARRAY [1…20] OF CHAR;
Vorname, Telefon : ARRAY [1...15] OF CHAR;
PLZ : CARDINAL;
Straße : ARRAY [1…30] OF CHAR;
Ort : ARRAY [1…20] OF CHAR;
Email : ARRAY [1…30] OF CHAR;
END;
TYPE ARRAY [1…1000] OF Visitenkarte;
8.3.2.4 Der Datetyp SET
enthält alle Werte einer gegebenen Grundmenge
Wertebereich:
P(T) = { x | x ≤ T }
Potenzmenge eines Grundtyps T (Menge aller Teilmengen einer Menge)
z.B. T = { 1, 2, 3 }
P(T) = { {}, {1}, {2}, {3}, {1,2}, {1,3}, {2,3}, {1,2,3}}
^= Anzahl 2³
Definition: Konstruktor „SET OF Grundtyp“
Operationen auf SET-Typen:
Wirtschaftsinformatik.doc
Erstellt von Klaus-Dieter Hutter
*
+
IN
Mengendurchchnitt (entspricht ∩ )
Mengenvereinigung (entspricht u )
Differenzmenge (entspricht \ )
Mengen-Einschluss (entspricht E )
Seite 31 von 38
Stand: 05.12.2006
Beispiel:
TYPE
Grundtyp = [ 1…3 ];
Mengentyp = SET OF Grundtyp;
m : Mengentyp;
VAR
BEGIN
m := { 1, 2, 3 } * { 1 };
END;
……
Überladung von Operanden
BEGIN
N := 5 x 10;
END
8.3.3 Dynamische strukturierte Datentypen
Datenstruktur wird während der Programmlaufzeit erzeugt
zwei Grundformen
a.) starre Strukturschablone
b.)
lediglich quantitative Änderungen der Komponenten (Anzahl) sind als
Strukturänderungen erlaubt
Sequenz-Struktur
flexibler, nahezu beliebiger Strukturaufbau während des Programmablaufs
möglich
Pointer
8.3.3.1 Der Datentyp SEQUENZ
geordnete Folge von Komponenten gleichen Typs
Anzahl nicht beschränkt (stets endlich)
Anzahl während Programmablauf veränderbar
Wertebereich:
M+ =
∞
u
Mi (Mi = Folge mit Länge i E N
i=0
Vorstellung: Magnetband unterteilt in einzelne Zellen, dabei enthält jede Zelle genau eine
Komponente.
Es kann nur die Komponente bearbeitet werden, die gerade unter dem Schreib/Lesekopf steht und das sequentiell.
Verwendung: für Ein- und Ausgabedaten von Sekundärspeichern sequentieller Datei/File
Definition: Konstruktor „FILE OF Grundtyp“
Beispiel:
TYPE IntegerFile = FILE OF INTEGER,
VAR f : IntegerFile;
Merke:
Zu jeder Filevariablen f wird automatisch eine Puffervariable f^ angelegt vom gleichen Typ
wie Komponenten von f, sie stellt das Bindeglied zwischen File und der Variablen dar.
Operationen: + Grundoperationen
a.) EOF (End of file) : EOF(f) = { TRUE } (a)
{ FALSE } (b)
(a) Sichtfenster steht hinter der letzten Komponente von f
(b) sonst
Wirtschaftsinformatik.doc
Erstellt von Klaus-Dieter Hutter
Seite 32 von 38
Stand: 05.12.2006
f^ --> ist hier undefiniert
Beispiel:
S-/L-Kopf
b.)
EOF(f) = TRUE
RESET
Zwei Fälle:
1. Fall: FILE ist nicht leer; RESET(f) bewirkt
Das Sichtfenster steht über der ersten Zelle
f^ hat als Wert den Inhalt der ersten Zelle von f
EOF(f) = FALSE
f^
2
f
2
7
1
3
EOF(f) = FALSE
S-/L-Kopf
2. Fall: FILE ist leer; RESET(f) bewirkt
Das Sichtfenster steht hinter leerem File
EOF(f) = TRUE
f^
?
EOF(f) = TRUE
f
vergleichbar mit Zustand bei Initialisierung
c.)
d.)
GET
Voraussetzung:
f^
2
f
2
EOF(f) = FALSE
wenn ja, verschiebt GET(f) das Sichtfenster um eine Zelle
nach rechts und weist f^ den Inhalt der Zelle zu
vor GET(f)
7
1
3
f^
f
7
2
7
nach GET(f)
1
3
REWRITE
löscht den Inhalt von f; anschließend liegt der gleiche Zustand vor wie bei der
RESET-Operation auf das leere FILE
Sichtfenster steht hinter leerem FILE
Wert von f^ undefiniert
EOF(f) = TRUE
Wirtschaftsinformatik.doc
Erstellt von Klaus-Dieter Hutter
Seite 33 von 38
Stand: 05.12.2006
e.)
PUT
Voraussetzung:
EOF(f) = TRUE
wenn ja, so fügt PUT(f) eine neue Zelle an das Fileende an
und weist ihr den Wert der Puffervariablen f^ zu. Danach
wird das Sichtfenster um eine Position nach rechts versetzt,
es gilt EOF(f) = TRUE. Der Wert von f^ ist undefiniert.
f^
f
2
7
1
f^ = ?
8
3
7
2
f
1
3
vor PUT(f)
8
nach PUT(f)
8.3.3.1.1 Beispiel Datentyp SEQUENZ
TYPE
VAR
Fx : File OF INTEGER;
f : Fx;
x,y : INTEGER;
Operation
REWRITE(f)
Wirkung
f^
?
EOF(f) = TRUE
f
----------------------------------------------------------------------------f^ := 17;
PUT(f);
f^
f
?
EOF(f) = TRUE
17
----------------------------------------------------------------------------f^ := 5;
PUT(f);
f^
f
17
?
EOF(f) = TRUE
5
----------------------------------------------------------------------------f^
RESET(f);
f
17
17
EOF(f) = FALSE
5
----------------------------------------------------------------------------x := f^;
GET(f);
f^
f
17
5
EOF(f) = FALSE
5
x = 17
-----------------------------------------------------------------------------
Wirtschaftsinformatik.doc
Erstellt von Klaus-Dieter Hutter
Seite 34 von 38
Stand: 05.12.2006
f^
y = f^;
GET(f)
f
17
?
EOF(f) = TRUE
5
x = 17
y=5
----------------------------------------------------------------------------f^
f^ := 8;
PUT(f);
f
17
5
?
8
EOF(f) = TRUE
Die beiden Anweisungen werden so häufig benötigt, dass sie in Prozeduren zusammengefasst
werden (z.B. in Pascal).
f^ := „Ausdruck“;
}
}
WRITE (f, „Ausdruck“) für
PUT(f);
Variable := f^;
READ (f, „Variable“) für
GET(f);
Das obige Beispiel kann wie folgt abgekürzt werden:
REWRITE(f);
WRITE(f, 17);
WRITE(f, 5);
RESET(f);
READ(f, x);
READ(f, y);
8.3.3.2 Der Datentyp POINTER
im praktischen Leben bei Abzählreimen (“Josephus”-Spiel) angewandt
8.3.3.2.1 Das Pointer-Konzept
Ein Pointer ist eine Variable, die einen Verweis auf eine andere Variable als Wert hat
Variable kann als Speicherplatz verstanden werden
die Variable, auf die verwiesen wird, nennt man referenzierte Variable
der Typ der referenzierten Variablen wird Bezugstyp genannt
die von einem Pointer p referenzierte Variable ist ansprechbar als p^ (alternativ: ↑p)
Als Symbol für einen Pointer p und die referenzierte Variable verwenden wir
Pointer p
referenzierte Variable p^
Pointer und referenzierte Variablen sind unabhängig voneinander.
Wirtschaftsinformatik.doc
Erstellt von Klaus-Dieter Hutter
Seite 35 von 38
Stand: 05.12.2006
Der Wert einer Pointervariablen ist entweder
undefiniert (z.B. direkt nach der Vereinbarung)
p ?
definiert:
Jetzt verweist p auf
entweder NIL (║; NIL unterscheidet sich von undefiniert, dass der Wert abgefragt
werden kann)
p
NIL
oder auf eine Variable p^ des Bezugtyps. Trifft dies zu, so kann der Wert von p^
o undefiniert (z.B. direkt nach der Erzeugung von p^)
p
?
p^
o definiert
p
Wert
p^
sein.
Das Interesse gilt der referenzierten Variablen p^, Pointer ist lediglich Hilfsmittel für den
Zugriff. Eine Veränderung von p^ ist nur über den Pointer möglich, hat jedoch keine
Auswirkung auf den Pointer selbst. Umgekehrt hat eine Änderung eines Pointers p keine
Auswirkung auf sein p^, allerdings ist p^ nicht mehr durch p ansprechbar.
Erzeugung einer Pointervariablen
per Vereinbarung statisch
TYPE PointerTypName = POINTER TO Bezugstyp;
VAR p : PointerTypName;
Erzeugung einer Variablen des Bezugtyps
NEW(p) erzeugt zur Laufzeit (dynamisch) eine Variable des Bezugtyps und weist
dem entsprechenden Zeigerwert p zu. Der Wert von p^ zu diesem Zeitpunkt
ist undefiniert.
Die Freigabe einer Variablen des Bezugtyps
DISPOSE(p) dann wird zur Laufzeit der Speicherplatz von p^ zur weiteren
Verwendung zurückgegeben; p hat den Wert NIL.
Wertzuweisung an Pointervariablen p durch
NEW(p)
p := q (Typgleichheit)
└→ dann gilt, das p^ = q^ ist.
DISPOSE(p)
p := NIL
8.3.3.2.2 Beispiel POINTER in PASCAL
TYPE string = ARRAY [0..9] OF CHAR;
ptr = POINTER TO Person;
Person = RECORD
Name : string;
next : ptr;
END;
Wirtschaftsinformatik.doc
Erstellt von Klaus-Dieter Hutter
Seite 36 von 38
Stand: 05.12.2006
Anweisung
VAR p,q : ptr;
Wirkung
p ?
q ?
-------------------------------------------------------------
NEW(p);
p
q ?
?
?
------------------------------------------------------------p^.Name := „Max“;
q ?
p
Max
?
-------------------------------------------------------------
NEW(q);
p
q
?
?
Max
?
------------------------------------------------------------p^.next := q;
q^.next := NIL;
p
q
?
Max
NIL
------------------------------------------------------------p.next.Name := “Lisa”;
p
q
Max
Lisa
NIL
------------------------------------------------------------q^.name := “Anne”;
p
q
Max
Anne
NIL
Wirtschaftsinformatik.doc
Erstellt von Klaus-Dieter Hutter
Seite 37 von 38
Stand: 05.12.2006
p^.next := NIL;
DISPOSE(q);
p
q
NIL
Max
NIL
Jede Variable des Bezugtyps enthält wieder einen Pointer
Verkettung von Variablen möglich
Ergebnis sind vielfältige Datenstrukturen
Vorteil:
dynamische Erzeugung von Komponenten nach Bedarf
Komponenten können in der Regel eingeführt und gelöscht werden, ohne die
umgebende Reststruktur verändern zu müssen
8.3.3.2.3 Operatorbaum
1) Wurzel ist die zuletzt ausführbare Operation
2) Der linke Teilbaum: Operatorbaum des linken Operanden
3) Der rechte Teilbaum: Operatorbaum des rechten Operanden
(a+b)*(c–d*e)
*
+
a
-
b
*
c
d
Wirtschaftsinformatik.doc
Erstellt von Klaus-Dieter Hutter
e
Seite 38 von 38
Stand: 05.12.2006
