Michael Neuhold Homepage
Startseite > Informatikunterricht > Turbo Pascal für Fortgeschrittene

Turbo Pascal für Fortgeschrittene

Das folgende ist nie ganz fertig geworden. Vor allem mangelt es an praktischen Beispielen, da man im Unterricht selten alle diese Themen abhandeln kann. Das Thema Objekte und objektorientierte Programmierung füllt Bücher; hier kann nur ein minimaler Hinweis auf die Syntax gegeben werden.

Typisierte Konstanten
Variante Records und Free Union
Datentyp Set
Forward-Deklaration
Pointer
- Typisierte Pointer
- Untypisierte Pointer
Objekte
Units
Direkte Speicherzugriffe

Typisierte Konstanten

Variablen wird beim Kompilieren eine Adresse im Datensegment (globale Variablen) oder beim Programmlauf im Stacksegment (lokale Variablen) zugewiesen. Daher kann ihr Wert während des Programmlaufes geändert werden. Sie haben aber beim Programmstart keinen definierten Wert.
Der Wert von Konstanten wird beim Kompilieren in das Codesegment eingetragen, daher ist eine Änderung des Wertes zur Laufzeit nicht möglich.
Ein Mittelding sind sog. typisierte Konstanten oder Variablenkonstanten:
```
CONST name: Typ = Wert;
```
Obwohl mit dem Schlüsselwort CONST vereinbart, handelt es sich eigentlich um Variablen mit einem definierten Startwert. Der Wert kann zur Laufzeit geändert werden.

Auch typisierte Record- und Arraykonstanten sind möglich; dazu muß der CONST-Teil aber nach der TYPE-Deklaration stehen:

TYPE  Faecher = (D, E, L, M, GW, GS, Ph, BU);
  PersDaten = RECORD
    name, vorname: String[30];
    titel: String[10];
    UFach: Faecher;
  END;
CONST direktor: PersDaten =
                  (name: 'Löwenzahn';
                   vorname: 'Hans';
                   titel: 'Hofrat';
                   UFach: M);

TYPE DreiLottoTips = ARRAY [1..3, 1..6] OF Byte;
CONST Tip17: DreiLottoTips =
               ((2,13,21,37,41,44),
                (8,12,27,31,38, 42),
                (15,19,21,23,29,31));

Variante Records und Free Union

Es besteht bei Records die Möglichkeit, Komponenten und ihre Typen vom Wert eines bestimmten Datenfeldes (dem sog. Tag Field) abhängig zu machen. Solche Records heißen Variante Records.
```
TYPE Person =
  RECORD
    name: String[20];
    GebDatum: String[10];
    geschlecht: Char;
    CASE stand: String[12] OF
      'ledig': ();
      'verwitwet', 'verheiratet', 'geschieden': (GebName: String[12]);
  END;
```
Wenn die Komponente stand den Wert 'verwitwet', 'verheiratet' oder 'geschieden' hat, besitzt der Record noch ein weiteres Feld GebName.
Der variante Teil wird mit CASE eingeleitet und muß immer am Ende der Recorddefinition stehen, da entgegen der sonstigen Regel das Case hier kein END hat.
Da die Datensatzlänge konstant bleiben muß, belegt der Record den Speicherplatz der längsten Variante.
Der Case-Teil muß eine vollständige Aufzählung aller möglichen Werte für das Tag Field enthalten. Daher ist bei Case hier - und nur hier! - auch der Datentyp String erlaubt.

Bei der Verarbeitung varianter Records muß man darauf achten, die korrekte Variante anzusprechen, am besten mit If oder Case:

IF (stand='verheiratet') OR (stand='geschieden') OR (stand='verwitwet') THEN
BEGIN
  write ('Bitte den Ledigennamen eingeben: ');
  ReadLn (GebName);
END;

Ein weiteres Beispiel:

TYPE  MitgliederStatus = (Aktiver, Wettkaempfer, Foerderer);
      Sportart = (Karate, Judo, Aikido);
Mitglied =
  RECORD
    name: String[25];
    CASE status OF
      Aktiver: (Disziplin: Sportart; BeitrErmaess: Boolean);
      Wettkaempfer: (Disziplin: Sportart; Punkte: Word);
      Foerderer: (Seit, GebDatum: String[10]);
  END;

Anstelle eines Tag Fields kann man bei Case auch nur einen Datentyp angeben, das nennt man Free Union. Dadurch kann man alle Alternativen gleichzeitig ansprechen.

TYPE  change =
  RECORD
    CASE Boolean OF
      TRUE: (ch: Char);
      FALSE: (n: Byte);
  END;
VAR  trick: change;

trick.ch:= 'A';
WriteLn ('Zeichen: ', trick.ch);
WriteLn ('Wert   : ', trick.n);
trick.n:= 66;
WriteLn ('Zeichen: ', trick.ch);
WriteLn ('Wert   : ', trick.n);

Dies wird z. B. vom Datentyp Registers (Unit dos) verwendet, seine Definition lautet:

TYPE  Registers =
  RECORD
    CASE Integer OF
      0: (ax, bx, cx, dx, bp, si, di, ds, es, flags: Word);
      1: (al, ah, bl, bh, cl, ch, dl, dh: Byte);
  END;

Datentyp Set

Sets sind Mengen von Elementen. Definition:
```
TYPE  SetTyp = SET OF ElementTyp;
VAR  MySet: SetTyp;
```
z.B. TYPE CharSet = SET OF Char;
ElementTyp muß ein ordinaler Datentyp mit nicht mehr als 256 möglichen Werten sein (Char, Byte, Aufzählungs- und Teilbereichstypen). Der Ordinalwert der Elemente muß zwischen 0 und 255 liegen.
Jedes Element kann nur einmal enthalten sein. Die Elemente haben die ihrem Typ entsprechende Reihenfolge.
Mengenelemente werden in eckige Klammern gesetzt. Die leere Menge wird [ ] geschrieben, Elemente werden mit + hinzugefügt:
```
CharSet:= [ ];
CharSet:= CharSet + ['D'];
```

Das Enthaltensein in einer Menge wird mit IN überprüft:

ErlaubteTasten:= [#13, #27, 'j', 'n'];
IF taste IN ErlaubteTasten THEN...

Forward-Deklaration

Normalerweise muß eine Prozedur/Funktion deklariert sein, bevor sie aufgerufen werden kann. Das ist aber nicht möglich, wenn Prozeduren sich gegenseitig aufrufen:
```
PROCEDURE Dies;
BEGIN ...; Das; END;

PROCEDURE Das;
BEGIN Dies; ...; END;
```
In einer solchen Struktur muß die aufgerufene Prozedur/Funktion mit der Anweisung FORWARD hinter dem Prozedurkopf deklariert werden, damit der Compiler eine Einsprungadresse erzeugen kann. Bei der eigentlichen Deklaration kann die Parameterliste ausgelassen werden:
```
PROCEDURE Flip (n: Byte); FORWARD;

PROCEDURE Flop (n: Byte);
BEGIN
  WriteLn ('Flop', n);
  IF n>0 THEN Flip (n-1);
END;

PROCEDURE Flip;
BEGIN
  WriteLn ('Flip', n);
  IF n>0 THEN Flop (n-1);
END;
```

Pointer

Ist ein Datentyp, der die Anfangsadresse eines Datums (Einzahl von Daten) enthält, und zwar in der Segment-Offset-Schreibweise, ein Pointer benötigt 4 Byte Speicher (2 Byte Offset, 2 Byte Segment).

Typisierte Pointer

Sind Zeiger auf Daten eines bestimmten Typs; Deklaration:

TYPE  ZeigerTyp = ^DatenTyp;   {vorangestelltes ^ bedeutet: Zeiger auf DatenTyp}
VAR   ZeigerVariable: ZeigerTyp;

Datentyp kann jeder beliebige Typ sein.
Man beachte genau den Unterschied zwischen der Zeigervariable (zeiger) und dem von ihr referenzierten Datum (zeiger^). Das Datum wird mit nachgestelltem ^ bezeichnet:
```
TYPE  IntPtr = ^Integer;
VAR   MerkZeiger: IntPtr;
WriteLn (MerkZeiger^);   {gib die Integerzahl aus, auf die MerkZeiger zeigt}
```
Die Zeigervariable wird im Datensegment (global) oder im Stacksegment (lokal) abgelegt, die referenzierten Daten im Heap (beginnt über dem Stack). Da für den Heap die Segmentmaximalgröße von 64 KByte nicht gilt, kann durch Verwendung von Zeigern die Segmentgrenze "gesprengt" werden.
Pascal-Speichermodell:

Heap

Stacksegment (max. 64 KByte)

Codesegment (- " -)

Datensegment (- " -)

Der Stack wird von oben nach unten (in Richtung auf das Codesegment) gefüllt.
Für die Daten, auf die ein Pointer zeigt, muß mit NEW (Zeiger) Speicherplatz auf dem Heap reserviert ("alloziert") werden. Werden die Daten nicht mehr benötigt, kann man mit DISPOSE (Zeiger) den allozierten Speicherplatz wieder freigeben.

Die häufigste Verwendung von Zeigern ist die verkettete Liste: ein Record enthält neben den Daten noch einen Zeiger auf den nächsten Record desselben Typs:

TYPE  ListPtr = ^ListElem; {hier keine explizite FORWARD-Deklaration nötig}
ListElem =
  RECORD
    item: String[20];      {Datum}
    next: ListPtr;         {Zeiger auf nächsten Record}
  END;

Will man einen Zeiger nirgendwohin zeigen lassen ("0"), weist man ihm den Wert NIL zu (NIL ist mit allen Zeigertypen zuweisungskompatibel): NeuZeiger:= NIL;

Einfach verkettete Liste

Liste initialiseren:

VAR   ListBeginn, ListPtr, NeuPtr: ListPtr;
ListPtr:= NIL;

Erweitern durch Einfügen am Anfang der Liste (FIFO):

New (NeuPtr);             {Zeiger für einen neuen Record allozieren}
ReadLn (NeuPtr.item);     {Datum einlesen}
NeuPtr.next:= ListBeginn; {neues Element auf erstes Element der Liste zeigen lassen}
ListBeginn:= NeuPtr;      {Zeiger auf Listenbeginn auf neues Element zeigen lassen}

Die Reihenfolge der Operationen ist wichtig!! Andernfalls würde die Liste unterbrochen, die Daten wären noch im Heap, es könnte aber nicht auf sie zugegriffen werden.

Erweitern durch Einfügen am Ende der Liste (LIFO):

VAR   ListBeginn, ListEnde, NeuPtr: ListPtr;
{*** initialisieren: ***}
ListBeginn:= NIL; ListEnde:= NIL;
{*** erstes Element einfügen: ***}
New (NeuPtr);
ReadLn (NeuPtr.item);
ListBeginn:= NeuPtr;
ListEnd:= NeuPtr;
NeuPtr.next:= NIL;
{*** weitere Elemente einfügen: ***}

Untypisierte Pointer

Sind Zeiger auf einen nicht festgelegten Datentyp; Deklaration:
```
VAR   zeiger: Pointer;
```
Der Speicher wird mit GETMEM (Zeiger, Größe) alloziert und mit FREEMEM (Zeiger, Größe) wieder freigegeben. Größe ist vom Typ Word und gibt den Speicherplatzbedarf in Byte an. Mit einem Aufruf von GetMem können max. 65528 Byte angefordert werden.
Wenn der größte zusammenhängende Speicherblock auf dem Heap kleiner ist, als der angeforderte Speicher, kommt es zu einem Laufzeitfehler. Die Funktion MAXAVAIL ermittelt die Größe des größten zusammenhängenden Speicherblockes (Ergebnis vom Typ LongInt), die Funktion MEMAVAIL die Gesamtmenge des noch freien Speicherplatzes auf dem Heap (Ergebnis vom Typ LongInt). Der Speicherbedarf von Daten kann mit der Funktion SIZEOF (Datum) ermittelt werden.
```
TYPE  TFriendRec =
  RECORD
    Name: string[30];
    Alter: Byte;
  END;
VAR   p: pointer;
BEGIN
  IF MaxAvail < SizeOf (TFriendRec) THEN
    WriteLn ('Nicht genügende Speicher')
  ELSE BEGIN
    GetMem (p, SizeOf (TFriendRec));  {Speicher auf dem Heap allozieren}
    {Speicher benutzen}
    FreeMem (p, SizeOf (TFriendRec)); {Speicher wieder freigeben}
  END;
END.
```

MARK (Heapspitze) liefert einen Zeiger auf die Heapspitze. RELEASE (Zeiger) gibt Heapspeicher ab Zeiger frei.

VAR   pTop: Pointer;
      p1,p2,p3: ^Integer;
BEGIN
  New(p1);       {Integer allozieren}
  Mark(pTop);    {Zeiger auf Heapspitze speichern}
  New(p2);       {zwei weitere Integer allozieren}
  New(p3);
  Release(pTop); {Speicher für p2^ and p3^ freigeben, p1^ kann weiter verwendet werden}
END;

Eine Verwendungsweise untypisierter Zeiger sind Bitmaps, die mit GetImage und PutImage behandelt werden.

Objekte

Methoden

Objekte sind, vereinfacht gesagt, Records, bei denen zusätzlich zu den Datenfeldern auch die Prozedurköpfe der Prozeduren/Funktionen (man spricht bei Objekten von "Methoden"), die auf diese Daten zugreifen, angibt:

USES  graph;
TYPE  RectObj =
  OBJECT
    x1, y1, x2, y2: Integer;
    PROCEDURE NewProps (nx1, ny1, nx2, ny2: Integer);
    PROCEDURE Draw (color: Byte);
  END;

VAR   Rechteck: RectObj;

PROCEDURE RectObj.NewProps (nx1, ny1, nx2, ny2: Integer);
BEGIN
  x1:= nx1; y1:= ny2; x2:= nx2; y2:= ny2;
END;

PROCEDURE RectObj.Draw (color: Byte);
BEGIN
  SetColor (color);
  Rectangle (x1, y1, x2, y2);
END;

Auf die Methoden greift man genauso zu wie auf Datenfelder von Records, also mit Objektvariable.Methodenname, z.B. Rechteck.Draw(LightRed);.

Der Vorteil der objektorientierten Programmierung (OOP) liegt darin, daß sich Seiteneffekte weitgehend vermeiden lassen, wenn man wirklich nur die Methoden des Objektes aufruft. Zwar wäre es auch weiterhin möglich, direkte Wertzuweisungen vorzunehmen (Rechteck.x1:= 100 usw.), doch widerspräche dies dem Konzept der OOP. Um diese direkten Datenmanipulationen überhaupt zu verhindern, kann (und sollte) man die Daten als PRIVATE deklarieren.

Vererbung

Eine besondere Stärke der OOP liegt in der Möglichkeit, neue Objekte von anderen Objekten abzuleiten (sog. Vererbung), wobei die abgeleiteten Objekte alle Daten und Methoden ihrer Mutterobjekte erben. Es ist nun möglich, diesen neue Daten und Methoden hinzuzufügen und die vererbten Methoden zu modifizieren (zu "überschreiben", engl. override).

TYPE  BarObj =
  OBJECT (RectObj)   {neues Objekt erbt alle Eigenschaften der Mutter}
    pattern: Byte;   {neues Datenfeld wird hinzugefügt}
    PROCEDURE Draw   {ererbte Methode wird modifiziert}
      (pattern, color: Byte);
    PROCEDURE Clear; {neue Methode wird hinzugefügt}
  END;

PROCEDURE BarObj.Draw;
BEGIN
  SetFillStyle (pattern, color);
  Bar (x1, y1, x2, y2);
END;

PROCEDURE BarObj.Clear;
BEGIN
  SetViewport (x1, y1, x2, y2, ClipOn);
  ClearViewport;
  SetViewport (0, 0, GetMaxX, GetMaxY);
END;

Dynamische Objekte

Sind Objekte, die über Zeigervariablen im Heap abgelegt werden. Um nun zu wissen, welche Methoden zu welchen Objekten gehören (was durch Vererbung und Überschreiben durchaus kompliziert sein kann), legt Pascal beim Kompilieren eine sog. Virtual Method Table (VMT) an, in die die Adressen erst zur Laufzeit eingetragen werden.
Damit ein Objekt seine Methodenadressen in die VMT einträgt, muß eine Methode (meist jene, die als erstes aufgerufen wird) als CONSTRUCTOR deklariert werden.
Damit ein Objekt sich wieder "abmeldet" und der Speicher auf dem Heap freigegeben wird, muß eine Methode als DESTRUCTOR deklariert werden (diese Methoden können auch leer sein, d.h. keinerlei Operationen ausführen).

Units

Prozeduren, Funktionen, Konstanten und Variablen, die man immer wieder benötigt, kann man, um sie nicht immer neu in den Quellcode hineinsetzen zu müssen, in eine Unit auslagern. Units sind bereits kompilierte Sammlungen von solchen Prozeduren etc., die beim Kompilieren des Programmes in den Programmcode eingebunden werden.
Der Maschinencode eines Pascalprogrammes kann nicht länger als 64 KB sein (Codesegment). Ist er länger, kann man Programmteile in Units auslagern, da Turbo Pascal für jede Unit ein eigenes Codesegment anlegt.

Eine Unit hat folgenden Aufbau:

{*** Programmkopf: ***}
UNIT queue;
{der Unitname muß mit dem Dateinamen identisch sein!}
USES ...;
{*** Benutzerschnittstelle: ***}
INTERFACE
{Deklaration der Prozedur- und Funktionsköpfe, Konstanten und Variablen,
die von außerhalb der Unit zugänglich sein sollen}
{*** Implementation: ***}
IMPLEMENTATION
{Implementation der Prozeduren und Funktionen. Prozeduren, die nur hier implementiert
sind, aber nicht im Interface-Teil stehen, können zwar von anderen Prozeduren
dieser Unit aufgerufen werden, nicht jedoch vom Programm, das diese Unit benutzt.}
{*** Programmteil:***}
BEGIN
{Hier können Variableninitialisierungen und Prozeduraufrufe stehen, kann aber auch
leer sein.}
END.

Der Unitname muß mit dem Dateinamen identisch sein, eine Unit queue muß also als queue.pas abgespeichert werden. Kompiliert man diese Unit, wird eine Datei namens queue.tpu (Turbo Pascal Unit) erzeugt. Dies ist die eigentliche Unit.

Direkte Speicherzugriffe

Eine der großen Stärken höherer Programmiersprachen besteht darin, daß sich der Programmierer nicht um die Verwaltung des Speichers (an welcher Adresse steht welche Variable, an welcher Adresse beginnt welche Prozedur usw.) kümmern muß.
Manchmal möchte man aber doch direkt auf Speicheradressen zugreifen. Dies geht mit den Funktionen MEM [Segment: Offset] (Ergebnis vom Type Byte) und MEMW [Segment: Offset] (Ergebnis vom Typ Word).

Autor: Michael Neuhold (E-Mail-Kontakt)
Erstellungsdatum: Irgendwann 1996/7
Letzte Aktualisierung: 10. Juni 2024