Pascal-Datentypen

1. Pascal-Datentypen Skalare Typen Zeiger- Typen Strukturierte Typen Inhomogene Typen Homogene Typen Aufzählungs- typen REAL Verbunde Unterbereichs- typen BOOLEAN Dateien Felder Selbstvereinbarte Typen INTEGER Mengen CHAR

2. 13. Strukturierte Datentypen und Zeiger Mengentypen: TYPE Mengentyp = SET OF Basistyp; als Basistyp sind nur endliche Aufzählungstypen zulässig TYPE Farben = (Rot, Gelb, Gruen, Blau, Schwarz, Weiss); Farbmenge = SET OF Farben; Operationen auf Mengen: S1 + S2 S1 * S2 S1 - S2 S1 / S2 S1 <= S2 S1 >= S2 x IN S Vereinigung der Mengen S1 und S2 Schnitt der Mengen S1 und S2 Differenz der Mengen S1 und S2 Symmetrische Differenz der Mengen S1 und S2 S1 ist Untermenge von S2 S1 ist Obermenge von S2 x ist Element von S Mengenkonstanten: [], [Rot, Gelb, Gruen], [1..5,9,17..19] Include(S,e) entspricht S := S + [e] Exclude(S,e) entspricht S := S - [e]

3. Reihung von Komponenten desselben (Werte-) Typs, dienen zur Aufnahme mehrer Objekte desselben Basistyps Traditioneller Datentypkonstruktor speziell für Vektoren oder Matrizen Feldelemente werden durch Index bezeichnet, der durch Aufzählungstypen, Unterbereichstypen, CHAR, INTEGER und BOOLEAN gebildet werden kann Zugriff auf einzelne Komponenten erfolgt über Indextyp Felder (Arrays) ARRAY [1..10] OF Integer ARRAY [-5..5] OF Real ARRAY [Boolean] OF (rot, gruen, blau) Feld mit 10 Integer-Komponenten Feld mit 11 Real-Komponenten Feld mit 2 Komponenten des angeg. Typs Wertetyp kann wieder Feld sein: ARRAY [I1] OF ARRAY [I2] OF ... ARRAY [In] OF T Einfachere Schreibweise ARRAY [I1,I2,...,In] OF T

4. Matrixmultiplikation CONST L1 = 6; L3 = 5; TYPE IndBer1 = 1..L1; IndBer2 = (Alpha, Beta, Gamma); IndBer3 = 1..L3; Vektor = ARRAY [IndBer3] OF INTEGER; Matrix1 = ARRAY [IndBer1, Alpha..Gamma] OF INTEGER; Matrix2 = ARRAY [Alpha..Gamma] OF Vektor; Matrix3 = ARRAY [IndBer1] OF Vektor; VAR M1 : Matrix1; M2 : Matrix2; M3 : Matrix3; PROCEDURE Multiplikation;(* Matrixmultiplikation M3 := M1 * M2 *) VAR i : IndBer1; j : IndBer2; k : IndBer3; Summe : INTEGER; BEGIN (* Multiplikation *) FOR i := 1 TO L1 DO FOR k := 1 TO L3 DO Summe := 0; FOR j := MIN(IndBer2) TO MAX(IndBer2) DO Summe := Summe + M1 [i, j] * M2 [j, k]; END (* FOR j *); M3 [i, k] := Summe; END (* FOR k *); END (* FOR i *); END Multiplikation;

5. Verbunde (Records) TYPE RecTyp = RECORD Selektor1 : Typ1; ... Seli, Selj: Typij; ... Selektorn : Typn; END (* RECORD *); dienen zur Darstellung inhomogener, aber zusammengehöriger Information Zugriff auf Komponenten durch <Recordname>.<Selektor> TYPE NamString = ARRAY [1..15] OF CHAR; IndexT = [1...100]; AnredeT = (Herr, Frau); NameRec = RECORD Vorname, Nachname : NamString; Anrede : AnredeT; END (* RECORD *); PersonRec = RECORD Name : NameRec; ...(* weitere Felder des Records *) END (* RECORD *); VAR Personal: ARRAY IndexT OF PersonRec; Beispielzugriff: Personal [3].Name.Vorname [1]

6. With-Anweisung: 3 äquivalente Programmstücke IF ('a' <= Personal [Index].Name.Vorname [1]) AND (Personal[Index].Name.Vorname [1] <= 'z') THEN Personal[Index].Name.Vorname [1] := CHR (ORD ('A') - ORD ('a') + ORD (Personal [Index].Name.Vorname [1])); END (* IF *); WITH Personal [Index] DO IF ('a' <= Name.Vorname [1]) AND (Name.Vorname [1] <= 'z') THEN Name.Vorname [1] := CHR (ORD ('A') - ORD ('a') + ORD (Name.Vorname [1])); END (* IF *); END (* WITH *); WITH Personal [Index].Name DO IF ('a' <= Vorname [1]) AND (Vorname [1] <= 'z') THEN Vorname [1]:= CHR (ORD ('A') - ORD ('a') + ORD (Vorname [1])); END (* IF *); END (* WITH *);

7. PROGRAM RecTest; CONST MaxPers = 10; MaxLng = 30; TYPE DatumT = RECORD Jahr : [0..3000]; Monat : [1..12]; Tag : [1..31]; END (* RECORD *); String = ARRAY [0..MaxLng] OF CHAR; NamTyp = RECORD (* mit drei Feldern gleichen Typs *) VorName, NachName, GebName : String; END (* RECORD *); GebAng = RECORD (* bestehend aus Record und Array *) Datum: DatumT; Ort: String; END (* RECORD *); EheAng = RECORD Stand : (ledig, verh, verw, gesch, gest); seit : DatumT; END (* RECORD *); PersAng = RECORD Name : NamTyp; Geburt : GebAng; ZivStand: EheAng; END (* RECORD *); VAR Person1, Person2 : PersAng; Datum1, Datum2 : DatumT; Klasse : ARRAY [1..MaxPers] OF PersAng; Name : NamTyp;

8. RecTest, ctd. BEGIN (* RecTest *) Person1.Name.VorName := 'Albert'; Person1.Name.NachName := 'Einstein'; (* sehr umstaendlich! *) WITH Datum1 DO Jahr := 1879; Monat:= 3; Tag := 14; END; WITH Person1 DO WITH ZivStand DO (* das aeussere WITH bleibt wirksam *) Stand := gest; seit := Datum1; seit.Jahr := 1955; END (* WITH ZivStand *); Geburt.Datum := Datum1; (* Wertzuw. eines Teil-Records *) Geburt.Ort := 'Ulm'; END (* WITH Person1 *); Person2 := Person1; (* Wertzuweisung eines Records *) Klasse [5] := Person1; WITH Klasse [3] DO Name := Person2.Name; (* d.h. Klasse[3].Name := Person2.Name *) END (* WITH Klasse [3] *); END (* RecTest *).

9. Nachteile: es wird immer Speicherplatz für 5000 Bücher bereitgestellt beim Entfernen von Büchern entstehen Lücken, die zu verwalten sind Einfügen eines Buches kann erhebliches Umspeichern nötig machen Deshalb empfiehlt sich Verwendung dynamischer verketteter Listen Zeiger (Pointer) Aufgabe: Erstellen einer Bücherkartei, alphabetisch sortiert TYPE Buch = RECORD Autor: RECORD Vn, Nn: ARRAY[1..25] OF Char END; Titel: ARRAY[1..200] OF Char; Jahr: 1800..2010; Verl: Boolean END; Beschreibung durch Feld: VAR Kartei: ARRAY[1..5000] OF Buch

10. Verkettete Listen Kopf D A B C Listenelemente X D D A B C A B C Löschen eines alten Elements Einfügen eines neuen Elements

11. Bezeichner von Zeigertypen können vor entsprechenden Objekttypen deklariert werden! nach TYPE Z = ^T;VAR X: Z; ist X^Variable (i.e.S. Zeigervariable) vom Typ T, ihr Wert das Objekt, auf das X zeigt. Wertebereich jedes Zeigertyps enthält Konstante NIL (zeigt auf nichts) Zuweisung von NIL an Zeigervariable X löscht gespeicherten Zeiger, Zugriff über X^ dann nicht mehr erlaubt Zeiger in Pascal TYPE Z = ^T; definiert Zeigertyp Z über Typ T, Wert: Adresse eines Objekts von Typ T TYPE Zeiger = ^Buchkarte; Buchkarte = RECORD Nachfolger: Zeiger; Beschreibung: Buch END;

12. Zuweisungsbeispiel Z1, Z2 und X sind Variablen vom Typ Z X X X ... ... ... Z1 Z1 Z1 1 2 1 2 3 2 ... ... ... Z2 Z2 Z2 4 4 3 3 4 3 nach Zuweisung Z1 := Z2 nach Zuweisung Z1^ := Z2^ Ausgangssituation

13. Ausführung von New(V) bewirkt • Erzeugen eines neuen Objekts vom Typ T • Ablegen des Zeigers auf neues Objekt in V, Objekt also mit V^ ansprechbar Dynamisches Erzeugen von Variablen TYPE Z = ^T; VAR V: Z; ? neues Objekt Typ T Wert noch undefiniert V V vorher nach New(V) Dispose(V) macht die Wirkung wieder rückgängig das Objekt, auf das V zeigt, wird zerstört, d.h. sein Speicherplatz freigegeben

14. Einfügen und Löschen von Listenelementen TYPE Buch = ... (* wie oben *) Zeiger = ... (* wie oben *) Buchkarte = ... (* wie oben *) VAR Kartei: Zeiger (* Kopf der Liste *) Hier,Neu: Zeiger (* Hilfszeiger *) Einfügen nach Hier New(Neu); Neu^.Nachfolger := Hier^.Nachfolger; Hier^.Nachfolger := Neu; Einfügen am Anfang New(Neu); Neu^.Nachfolger := Kartei; Hier^.Nachfolger := Neu; Löschen nach Hier Hier^.Nachfolger := Hier^.Nachfolger^.Nachfolger;

15. Suchen in Listen TYPE Element = ... (* Def. der Listenelemente *) Zeiger = ^Listenobjekt; Listenobjekt = RECORD Nachfolger: Zeiger; Inhalt: Element END; FUNCTION Listensuche(Was:Element;Wo:Zeiger):Zeiger; BEGIN (* Listensuche *) Listensuche := nil; WHILE Wo <> nil DO IF Wo.Inhalt = Was THEN BEGIN Listensuche := Wo, Wo := nil END ELSE Wo := Wo^.Nachfolger END (* Listensuche *) Folgende Funktion liefert Zeiger auf erstes Listenobjekt ab Wo, für das gilt Inhalt = Was

16. Doppelt verkettete Listen ... nil ... nil A B D C Kopf Ende TYPE Buch = ... (* wie oben *) Zeiger = ^Buchkarte Buchkarte = RECORD Vorgaenger, Nachfolger: Zeiger; Beschreibung: Buch END; VAR Kopf,Ende:Zeiger (* Kopf der Liste *) Hier,Neu: Zeiger (* Hilfszeiger *) Einfügen nach Hier Neu^.Vorgaenger := Hier; Neu^.Nachfolger := Hier^.Nachfolger; Hier^.Nachfolger^.Vorgaenger := Neu; Hier^.Nachfolger := Neu;