Programmiersprache Pascal

Lebensdauer von Variablen

Die Lebensdauer einer Variablen hängt davon ab, Prinzipiell gibt es folgende Möglichkeiten (Speichermodelle):
  1. Der Speicherplatz wird bei Programmstart zugewiesen und steht während der gesamten Laufzeit des Programms zur Verfügung.
    (statische Variablen)
  2. Der Speicherplatz wird bei Eintritt in den Block zugewiesen, in dem die Variable deklariert worden ist und steht bis zum Verlassen des Blocks zur Verfügung.
    (automatische Variablen)
  3. Der Speicherplatz wird explizit zur Laufzeit angefordert und steht solange zur Verfügung, bis er explizit wieder freigegeben wird. Anforderung und Freigabe erfolgt jeweils durch Prozeduraufrufe.
    (dynamische Variablen)
  4. Der Speicherplatz wird implizit zur Laufzeit angefordert und steht mindestens solange zur Verfügung, wie er benötigt wird. Er wird freigegeben, sobald festgestellt wird, daß er nicht mehr verwendet nicht (garbage collection, automatisch oder per Prozeduraufruf). (dynamische Variablen)
Statische Variablen

Alle global deklarierten Variablen stehen während der gesamten Laufzeit des Programms zur Verfügung.
Variablen sind global, wenn sie im Programmblock deklariert worden sind:

  PROGRAM name (...);
    ...
    VAR ...
    ...
  BEGIN
    ...
  END.
Globale Variablen können sowohl als statisch als auch als automatisch angesehen werden:
Der Block, bei Eintritt ihnen Speicherplatz zugewiesen wird, ist der Programmblock.

Ob nichtglobale Variablen statisch oder automatisch sind, hängt vom jeweiligen Pascal-System ab.
Denkbar ist bei neueren Pascal-Systemen folgende Variante:

XL Pascal

Gnu Pascal

Statische Variablen können mittels

  VAR name : __static__ typ;
deklariert werden.
Variablen sind ansonsten automatisch.

Automatische Variablen

Durch den Pascal Standard sind keine Mittel vorgesehen, welche die Anwendung des automatischen Speichermodells erzwingen.

In einzelnen Pascal-Systemen gibt dazu Spracherweiterungen.
(Siehe die obigen Bemerkungen zu XL und Gnu Pascal).

Dynamische Variablen

Dynamische Variablen in der Variante 3 sind in allen Pascal-Systemen möglich.
Variante 4 ist für Pascal-Systeme nicht typisch.

Dynamische Variablen werden mit Hilfe von Zeigern realisiert.
Zur Anforderung von Speicherplatz (auf dem Heap) dient die Prozedur New, zur Freigabe von Speicherplatz die Prozedur Dispose:

  TYPE typ = ...;
  VAR p : ^typ;
    ...
  New(p);           { dynamische Variable erhält Speicherplatz }
    ...
  Dispose(p);       { Speicherplatz wird freigegeben }
Achtung:
Die dynamische Zuordnung von Speicherplatz kann fehlschlagen. Dies ist zum Beispiel dann der Fall, wenn der zur Verfügung stehende Speicher erschöpft ist.
Das Programmverhalten kann bei einem solchen Fehlschlag systemspezifisch sein. Kommt es zu keinem Programmabbruch, so sollte die dynamische Variable den Wert NIL besitzen.
Zumindest kritische Anwendungen sollten prüfen, ob nach der Ausführung von New die dynamische Variable einen von NIL verschiedenen Wert besitzt.

Bemerkung:
Verschiedene Pascal-Systeme lassen für New eine erweiterte Syntax zu.
Manchmal kann New auch wie eine Funktion genutzt werden:

  zeiger_variable := New(typ);           { !! nicht im Standard !! }

Das folgende Beispiel soll Probleme verdeutlichen, die im Zusammenhang mit der Lebensdauer von Variablen auftreten können:

  PROGRAM stat(OUTPUT);           { Gnu Pascal }

  VAR n : INTEGER VALUE 0;        { globale Variable }

  PROCEDURE up;
  VAR n1 : INTEGER VALUE 0;
      n2 : INTEGER;
      n3 : __STATIC__ INTEGER;    { statische Variable, Gnu Pascal Syntax }
  CONST n4 : INTEGER = 0;         { "typ. Konstante", Turbo Pascal Syntyx }
  BEGIN
    n  := n  + 1;
    n1 := n1 + 1;
    n2 := n2 + 1;
    n3 := n3 + 1;
    n4 := n4 + 1;
    Writeln(n, ' ', n1, ' ', n2, ' ', n3, ' ', n4);
  END;

  PROCEDURE up2;
  BEGIN
    Writeln('*** Aufruf von up2 ***');
  END;

  BEGIN
    up;
  { up2; }
    up;
    up;
  END;
Testergebnisse:
           1          1          1          1          1
           2          1          2          2          1
           3          1          3          3          1
Testergebnisse nach Einfügung des auskommentierten Aufrufs von up2
           1          1          1          1          1
  *** Aufruf von up2 ***
           2          1  804781001          2          1
           3          1  804781002          3          1
Die Ergebnisse zeigen folgendes: Schlußfolgerung:
Der Programmierer sollte niemals systemspezifisches Verhalten ausnutzen.

Bemerkung:
Portables Verhalten soll bedeuten, daß das Verhalten auf anderen Rechnerplattformen bei Nutzung unterschiedlicher Pascal-Systeme reproduzierbar ist.



P. Böhme, 16.07.1996