Embed Size (px)
Citation preview
Teil X
Von Mini–Pascal zu Pascal
1
Teil X.1
Pascal Datentypen
2
Begriffe
• Typ: Menge von Werten
Beispiel: integer
alle ganzen Zahlen zwischen - MaxInt und MaxInt
• Variable: Reserviert Speicherplatz fur Werte ihres Typs
• Zuweisung: Weist einer Variablen einen Wert zu.
3
Einfache Datentypen
• Integer: alle ganzen Zahlen - MaxInt und MaxInt
Varianten:
• byte: 0..255
• word: 0..MaxInt
• LongInt: - MaxInt2..MaxInt2 − 1
• ShortInt: -128..127
• Boolean: True oder False
• Char: Meist ASCII-Code 32..127
• Real: Exponentendarstellung nach IEEE 754/854
Varianten:
• single: 32 bit
• double: 64 bit
• extended: 80 bit
• String: Zeichenketten (beliebiger Lange) zwischen ’ ’
4
Typkonstruktoren (1)
Array: Vektor fester Lange, Matrix mit fester Große
• Syntax: ’’array’’ ’’[’’ Bereichstyp ’’]’’ ’’of’’ Type
• Beispiele:
array[0..10] of Integer
array[’a’..’z’] of Integer
type matrix = array[0..10] of array [0..6] of Real
type matrix1 = array[0..10,0..6] of Real
• Zugriff:
var m: matrix;
m[3,2] := 7.3;
5
Typkonstruktoren (2)Record: Verbund uber Typen T1 × . . .× Tn
• Beispiel:type Datum = record
Tag : 1..31;Monat : (Jan, Feb, Mar, Apr, Mai, Jun,
Jul, Aug, Sep, Okt, Nov, Dez);Jahr : Integer
end;
• Zugriff:
var date: Datum;date.Monat := Jan;with date do
beginTag := 3;Monat := Jun;Jahr := 2002end;
6
Typkonstruktoren (3)
case Record mit Varianten
Beispiel:
type Stand = (verh, verw, gesch, ledig);
Person = record
name : record vorname, nachname : string end;
Versnr : integer;
Geschlecht : (Mann, Frau);
Geburt : Datum;
Kinder : integer;
case stkomp : Stand of
verh, verw : (vd : Datum);
gesch : (gd : Datum);
ledig : (unabh : boolean);
end;
7
Typkonstruktoren (4)
Set: Menge von Ordinaltypen
• Syntax: ’’set’’ ’’of’’ OrdinalerTyp
• Beispiel: type myset = set of Integer
• Operationen:
• + Mengenvereinigung
• - Komplementbildung
• * Durchschnitt
• in ElementOf
8
Zeigertypen (1)Zeiger: Addresse auf Speicher eines gegebenen Typs
• Beispiel:
type Liste = ^Eintrag;Eintrag = record
Elem : Integer;Nachfolger : Liste
end;var : anfang, neu, p, q : liste;
• Operationen:
• new(v) fordert freien Speicher vom Typ T an
• Zugriff auf Wert: v^
• dispose(v) gibt Speicher fur v wieder frei.
9
Zeigertypen (2)
Erzeugen einer Liste
anfang := nil; (* leere Liste erzeugen *)
new(anfang);
(* Es wird eine Variable anfang^ vom Typ Eintrag erzeugt *)
anfang^.Elem := 2;
anfang^.Nachfolger := nil;
(* nun hat die Liste ein Element *)
(* der Listenanfang ist erzeugt *)
10
Zeigertypen (3)
Einfugen eines Elements an den Anfang
p := anfang;
new(anfang);
anfang^.Nachfolger := p;
anfang^.Elem := 5;
11
Zeigertypen (4)
Einfugen eines Elements an das Ende
p := Anfang;
while p^.Nachfolger <> nil do
p := p^.Nachfolger;
new(q);
q^.Nachfolger := nil;
q^.Elem := y;
p^.Nachfolger := q; (* Eintrag an alte Liste gehaengt *)
12
Zeigertypen (5)
Suchen eines Elements elem = x
p := anfang; found := false; leer := false;
while not found and not leer do begin
if (p <> nil) then begin
if p^.Elem = x then
found := true
else
p := p^.Nachfolger
end
else leer := true;
if found then
writeln(’gefunden’)
else
if leer then writeln(’nicht vorhanden’);
end; (* while *)
13
Zeigertypen (6)
Einfugen eines Elements nb nach dem Element nach
p := anfang; found := false; leer := false;while not found and not leer do begin
if (p <> nil) then beginif p^.Elem = nach then
found := trueelse
p := p^.Nachfolgerendelse leer := true;if found then
writeln(’gefunden’)else
if leer then writeln(’nb nicht vorhanden’);end; (* while *)if found then begin
new(q);q^.Nachfolger := p^.Nachfolger;q^.Elem := nb;p^.Nachfolger := q
end;
14
Zeigertypen (7)Loschen des ersten Elements mit Wert x
if (anfang <> nil) then beginif (anfang^.Elem = x) then begin
p:=anfang^.Nachfolger;dispose(anfang);anfang:=p
end (* if erstes Element = x *)else begin
p := anfang; found := false; leer := false;while not found and not leer do begin
if (p^.Nachfolger <> nil) then beginif (p^.Nachfolger^.Elem = x) then
found := trueelse
p := p^.Nachfolgerendelse leer := true;
end; (* while *)if found then begin
q:=p^.Nachfolger^.Nachfolger;dispose(p^.Nachfolger);p^.Nachfolger:=q
end;end; (* if erstes Element <> x *)
end (* if anfang <> nil)
15
Dateien
• Syntax: ’’file’’ [’’of’’ Typ].
• Semantik: Folge von Komponenten mit gegebenen Typ.
• Operationen (in ISO-Pascal):
• get(F) lese aktuelle Komponente und schalte F auf die nachste
Komponente
• reset(F) offnen von F zum Lesen
• put(F) schalte F auf die nachste Komponente zum Beschreiben
• rewrite(F) offnen, initialisieren von F fur Schreibvorgang
• eof(F) Abfrage auf Dateiende
• close(F) Schließen einer Datei.
16
Teil X.2
Kontrollstrukturen, Prozeduren,
Funktionen
17
Kontrollstrukturen
Repeat-Anweisung = "Repeat" statement {";" statement }
"until" expression.
For-Anweisung = "for" Laufvariable ":=" expression
("to" | "downto") expression "do"
statement.
If-Anweisung = "if" expression "then" statement
["else" statement].
Case-Anweisung = "case" expression "of"
Bereich ":" statement
{Bereich ":" statement}
["else" ":" statement]
18
Prozeduren mit Parametern
• Syntax:
procDecl = "procedure" ident [ Interface ]; block;interface = "(" [var] ident ":" Type {; [var] ident ":" Type} ")"
• Wertparameter: ident ’’:’’ Type
Die Variable ident wird bei Aufruf mit dem Wert des aktuellen
Parameters (Variable oder Ausdruck) belegt, Anderung von ident
innerhalb der Prozedur nach außen nicht sichtbar.
• Referenzparameter: var ident ’’:’’ Type
Die Variable ident wird bei Aufruf mit einer Referenz auf den
aktuellen Parameter (nur Variable) belegt, Anderung von ident
innerhalb der Prozedur ist nach außen sichtbar. Nutzlich fur struk-
turierte Ausgaben.
19
Beispiel: Wert- vs. ReferenzparameterProgram callByValueVsCallbyRef
var i,j,k: integer
procedure p(var i1: integer; j1: integer)
begin
j1:=j1+1; (* ? *)
i1:=i1+j1;
end
begin
i:=0; j:=1; k:=2;
writeln(’before: i:’, i, ’, j:’ j, ’, k:’,k);
p(i,j*k);
writeln(’after: i:’, i, ’, j:’ j, ’, k:’,k)
end.
(* Ergebnis:
before: i : 0, j:1, k:2
after: i : 3, j:1, k:2 *)
20
Verschrankt rekursive Prozeduren• Problem: Verwendung einer Prozedur vor Deklaration• Losung: Trennung von Deklaration und Implementierung mit Hilfe von forward
Program abwechselnd;var i, h : integer;procedure q (var k : integer); forward;procedure p (var i, j : integer);begin
inc(i);j := i+5;if j < 10 then begin write(’ q:’, j); q(j) end;
end;procedure q;begin
inc(k);write(’ p:’, k);p(i, k)
end;begin
i := 0; h := 1;write (’ p:’, h);p(i, h);writeln(’ p:’, h)
end.(* Ergebnis: p:1 q:6 p:7 q:7 p:8 q:8 p:9 q:9 p:10 p:10 *)
21
Ablauf der verschrankten Rekursion
i:=0; h:=1;writeln(’ p:’, h); (* p: 1 *)p(i,h); (* i=0, h=1 *)
inc(i);j:= i+5;if j < 8 then begin
writeln(’ q:’, j); (* q: 6 *)q(j); (* j=6 *)
inc(k);writeln(’ p:’ k); (* p: 7 *)p(i,k); (* i=1, k=7 *)
inc(i);j:= i+5;if j < 8 then begin
writeln(’ q:’, j) (* q: 7 *)q(j); (* j=7 *)
inc(k);write(’ p:’, k); (* p: 8 *)p(i,k); (* i=2, k=8 *)
inc(i);j: = i+5 (* j=8 *)if j < 8 then ...
writeln(’ p:’, h) (* p: 8 *)
22
FunktionenWie Prozeduren, jedoch mit explizitem Ruckgabeparameter
• Syntax: Nur einfache Ruckgabetypen erlaubt.
funcDecl ="function" ident [Interface]: Type;block;
• Beispiel:
function rfak(n : word) : word;begin
if n=0 then rfak := 1 else rfak := rfak(n-1) * nend;
• Vergleiche:
procedure rfak(n : word; var ret: word);begin
if n=0 then ret := 1 elsebegin rfak(n-1,ret); ret := ret * n end;
end;
23
Beispiel: Minicompiler
Aufgabe: Ubersetze folgende Syntax in Maschinenprogramm
Wertzuweisung = ("a" | ... | "z") ":" "=" Ausdruck ";"
Ausdruck = Term {("+" | "-") Term}
Term = Faktor {("*" | "/") Faktor}
Faktor = "a" | ... | "z" |
("(" Ausdruck ")")
24
Minicompiler: Hauptprogrammprogram Minicompiler;uses wincrt;var i: Byte;
s: String[80];{80 Zeichen maximal}
procedure Fehler(i: byte);beginwriteln(’Fehler in Position ’,i:2);
end;
...
begin {Hauptprogramm}write(’Wertzuweisung einlesen ’);write(’- ohne Leertaste - ’);writeln(’mit Semikolon zum Ende: ’);readln(s); i:= 1;while s[i] <> ’X’ dobegin
writeln; Wertzuweisung(s,i);writeln(’Press X to stop’);readln(s); i:= 1
endend.
25
Regel fur Wertzuweisung
(* verschraenkte Rekursion *)
procedure Ausdruck(var s: String[80]; var i: Byte); forward;procedure Term(var s: String[80]; var i: Byte); forward;procedure Faktor(var s: String[80]; var i: Byte); forward;
(* Wertzuweisung = ("a"|...|"z") ’:’ ’=’ Ausdruck ";" *)
procedure Wertzuweisung(var s: String[80]; var i: Byte);var ch: Char;begincase s[i] of’a’..’z’:
beginch:= s[i]; inc(i);if s[i] <> ’:’ then Fehler(i); inc(i);if s[i] <> ’=’ then Fehler(i); inc(i);Ausdruck(s,i); writeln(’STORE ’, ch);if s[i] <> ’;’ then Fehler(i)
endelse Fehler(i)
endend; {Wertzuweisung}
26
Regel fur Ausdruck
(* Ausdruck = Term {("+" | "-") Term} *)
procedure Ausdruck(var s: String[80]; var i: Byte);var stop: boolean;beginTerm(s,i);stop:=false;repeat
case s[i] of’+’: begin
inc(i); Term(s,i); writeln(’ADD’)end;
’-’: begininc(i); Term(s,i); writeln(’SUB’)end
else stop:=true;end;
until stopend; {Ausdruck}
27
Regel fur Term
(* Term = Faktor {("*" | "/") Faktor} *)
procedure Term(var s: String[80]; var i: Byte);var stop: boolean;beginstop:=false;Faktor(s,i);repeat
case s[i] of’*’: begin
inc(i); Faktor(s,i); writeln(’MULT’)end;
’/’: begininc(i); Faktor(s,i); writeln(’DIV’)end
else stop:=true;end;
until stop;end; {Term}
28
Regel fur Faktor
(* Faktor = "a" | .. | "z"| ("(" Ausdruck ")") *)
procedure Faktor(var s: String[80]; var i: Byte);begincase s[i] of’a’..’z’:
beginwriteln(’LOAD ’,s[i]); inc(i)
end;’(’: begin
inc(i); Ausdruck(s,i);if s[i] <> ’)’ then Fehler(i)else inc(i)end
else Fehler(i)end
end; {Faktor}
29
Teil X.3
Objektorientierte Programmierung in
Pascal
30
Grundbegriffe der Objektorientierten Program-mierung
• Objekttyp: (Klasse) Kombination von Daten (Zustand) mit Pro-grammen (Methoden)
• Kapselung: Nur offentliche (public) Methoden und Variablen sindaußerhalb einer Klasse sichtbar; auch genannt: Interface einerKlasse.
• Vererbung: Ableitung neuer Klassen aus einer bereits bestehendendurch Hinzufugen von Methoden und Variablen.
• Konstruktor: Methode zum Erzeugen eines Objekts
• Destruktor: Methode zum Loschen eines Objekts
31
Beispiel: Geometrische Figuren
10.4 Unit{Konzepte und objektorientierte Programmierung 138
leitet werden. (Polygon ist insbesondere ein Polygonzug)
� Dreiecke sind spezielle Polygone und k�onnen als eine Unterklasse von Polygon gebildet
werden.
� Beliebige Rechtecke, die im Bezugspunkt des Graphikobjektes liegen, sollen durch die
Angabe von zwei L�angen und einem Winkel festgelegt sein. Der Winkel wird dabei
durch die X{Achse des lokalen Koordinatensystems und der Seite, die im Gegenuhr-
zeigersinn die erste ist, gebildet. Diese Seite soll die L�ange Breite besitzten. Die zweite,
im Nullpunkt des lokalen Systems darauf im Gegenuhrzeigersinn senkrecht stehende
Seite soll die L�ange Hoehe besitzen. Wir m�ussen also bei der Ableitung aus der Klasse
GrObjekt weitere Merkmale f�ur den Winkel und die beiden L�angen hinzuf�ugen.
� Quadrate k�onnen, da sie ein Spezialfall von Rechtecken sind, als Unterklasse der Klasse
Rechtecke eingef�uhrt werden. F�ur ihre De�nition gen�ugt { unter den gleichen Vor-
aussetzungen wie bei Rechtecken { die Angabe einer L�ange.
� Ellipsen sollen �ahnlich wie Rechtecke durch zwei L�angen, die L�angen der beiden Halb-
achsen, und einem Winkel spezi�ziert werden. Die Ellipse hat ihren Mittelpunkt im
Bezugspunkt (Nullpunkt des lokalen Systems), der Winkel wird analog zum Recht-
eck durch die X{Achse und die im Gegenuhrzeigersinn erste Halbachse eingeschlossen.
Die zweite Halbachse steht auf dieser im Gegenuhrzeigersinn senkrecht. Die Klasse
Ellipse hat wie ein Rechteck die zus�atzlichen Merkmale eines Winkels und zweier
L�angen, wird aber trotzdem direkt aus GrObjekt abgeleitet, da Rechteck und Ellipse
in keiner semantischen Beziehung zueinander stehen.
� Kreise sind spezielle Ellipsen, bei denen der Winkel keine Rolle spielt und die L�angen
der Halbachsen gleich sind. Deshalb k�onnen wir eine Klasse Kreis als Unterklasse der
Klasse Ellipse implementieren.
Eine m�ogliche Klassenhierarchie f�ur geometrische Figuren zeigt unser Bild:
10.4.3 Implementierung
In einem De�nitionsmodul werden die Merkmale und Methoden der verschiedenen Klas-
sen exakt de�niert und gleichzeitig die Hierarchiebeziehungen zwischen den Klassen fest-
gelegt.
32
GrObjekt Gemeinsame MethodenGemeinsame Methoden(-interfaces) und Variablen
Program Geometrische_Figuren;Type PunktRec = Record
x, y : Longint;End;
GrObjekt = CLASS(* In Borland Pascal muss das Schluesselwort *)(* CLASS durch OBJECT ersetzt werden *)
Bezugspunkt : PunktRec;Sichtbar : Boolean;
Constructor Init (x, y : Longint);Destructor Done ;Procedure Verschiebe(dx, dy : Longint);Procedure Zeichne; Virtual;Procedure Anzeigen;Procedure Loesche;
End; (* GrObjekt *);
33
Punkt und Strecke
Spezifische Implementierung fur Konstruktor, Destruktor, Zeichnen
Zusatzliche Methode Skaliere
Punkt = CLASS(GrObjekt)
Constructor Init (x, y : Longint);
Destructor Done ;
Procedure Zeichne; Virtual;
End; (* Punkt *)
Strecke = CLASS(GrObjekt)
P1 : Punkt;
Constructor Init (xa, ya, xb, yb : Longint);
Destructor Done ;
Procedure Skaliere (F : Real);
Procedure Zeichne; Virtual;
End; (* Strecke *)
34
Polygon und Dreieck
Neue Methode Flache
Const MaxPunkte = 100;
Type PktVektor = Array[0..MaxPunkte] Of PunktRec;
PolygonS = CLASS(GrObjekt)
Constructor Init (PV : PktVektor);
Destructor Done ;
Procedure Zeichne; Virtual;
Procedure Skaliere (F : Real);
Function Flaeche : Real;
End; (* PolygonS *)
Dreieck = CLASS(PolygonS)
Constructor Init (xa, ya, xb, yb, xc, yc : Longint);
Destructor Done ;
Procedure Zeichne; Virtual;
Function Flaeche : Real;
End; (* Dreieck *)
35
Rechteck und Quadrat
Neue Eigenschaften: Winkel, Breite, Hohe
Rechteck = CLASS(GrObjekt)
Winkel : Real;
Breite, Hoehe : Real;
Constructor Init (xa, ya : Longint; W, B, H : Real);
Destructor Done ;
Procedure Skaliere (F : Real);
Procedure Zeichne; Virtual;
Function Flaeche : Real;
End; (* Rechteck *)
Quadrat = CLASS(Rechteck)
Constructor Init (xa, ya : Longint; W, B: Real);
Destructor Done ;
Procedure Zeichne; Virtual;
End; (* Quadrat *)
36
Implementierung: Konstruktor
Getrennt von Interface-Deklaration:
Constructor Punkt.Init (x, y : Longint);
Begin
Bezugspunkt.x := x;
Bezugspunkt.y := y;
Sichtbar := true
End; (* Punkt.Init *)
37
Implementierung: Verschiebe
Verwendung von spezifischen Methoden (Zeichne) in einer generischen
Methode (Verschiebe)
Procedure GrObjekt.Verschiebe (dx, dy: LONGINT);
Begin
If sichtbar Then Begin
Loesche;
Bezugspunkt.x := Bezugspunkt.x + dx;
Bezugspunkt.y := Bezugspunkt.y + dy;
Zeichne
End;
End; (* Verschiebe *)
38
