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

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]

Felder (Arrays) 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 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

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;

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 *) VAR Personal: ARRAY IndexT OF PersonRec; Beispielzugriff: Personal [3].Name.Vorname [1]

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 *);

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; GebAng = RECORD (* bestehend aus Record und Array *) Datum: DatumT; Ort: String; EheAng = RECORD Stand : (ledig, verh, verw, gesch, gest); seit : DatumT; PersAng = RECORD Name : NamTyp; Geburt : GebAng; ZivStand: EheAng; VAR Person1, Person2 : PersAng; Datum1, Datum2 : DatumT; Klasse : ARRAY [1..MaxPers] OF PersAng; Name : NamTyp;

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 *).

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 Beschreibung durch Feld: VAR Kartei: ARRAY[1..5000] OF Buch 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

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

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; 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

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

Dynamisches Erzeugen von Variablen TYPE Z = ^T; VAR V: Z; 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 ? 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

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;

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

Doppelt verkettete Listen ... nil ... nil A B C D 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;