Variablen

Aus Appmethod Topics
Wechseln zu: Navigation, Suche

Nach oben zu Datentypen, Variablen und Konstanten - Index

Variablen sind Bezeichner für Werte, die sich zur Laufzeit ändern können. Eine Variable ist sozusagen ein Name für eine Speicheradresse. Sie kann für Lese- und Schreibzugriffe auf diese Speicheradresse verwendet werden. Variablen dienen als Container für Daten eines bestimmten Typs. Die Typisierung liefert dem Compiler Informationen darüber, wie die Daten zu interpretieren sind.

Variablendeklarationen

Die grundlegende Syntax für eine Variablendeklaration lautet:

var  Bezeichnerliste:Typ;

Bezeichnerliste ist eine durch Komma getrennte Liste gültiger Bezeichner, und Typ ist ein beliebiger gültiger Typ. Beispiel:

 var I: Integer;

Hier wird die Variable I mit dem Typ Integer deklariert, während

 var X, Y: Real;

die beiden Variablen X und Y vom Typ Real deklariert.

Bei aufeinander folgenden Deklarationen braucht das reservierte Wort var nicht wiederholt zu werden:

 var
    X, Y, Z: Double;
    I, J, K: Integer;
    Digit: 0..9;
    Okay: Boolean;

Variablen, die innerhalb von Prozeduren und Funktionen deklariert werden, werden als lokale Variablen bezeichnet. Alle anderen Variablen sind globale Variablen. Einer globalen Variable kann bei der Deklaration mit folgender Syntax ein Anfangswert zugewiesen werden:

var  Bezeichner: Typ = Konstante;

Konstante ist ein konstanter Ausdruck des Typs Typ. Somit entspricht die Deklaration

 var I: Integer = 7;

folgender Deklaration und Anweisung:

 var I: Integer;
     ...
 I := 7;

Lokale Variablen können nicht in ihren Deklarationen initialisiert werden. Aufeinander folgende Variablendeklarationen (z. B. var X, Y, Z: Real;) dürfen weder Initialisierungen enthalten noch Deklarationen von Varianten und Dateitypen.

Wenn Sie eine globale Variable nicht explizit initialisieren, wird sie vom Compiler mit 0 initialisiert. Objektinstanzdaten (Felder) werden auch mit 0 initialisiert. Auf der Wiin32-Plattform ist der Inhalt von lokalen Variablen so lange undefiniert, bis ein Wert zugewiesen wird.

Der bei der Deklaration einer Variablen zugewiesene Speicher wird automatisch freigegeben, wenn die Variable nicht mehr benötigt wird. Lokale Variablen werden freigegeben, wenn die Prozedur oder Funktion beendet wird, in der sie deklariert sind. Weitere Informationen über Variablen und die Verwaltung des Speichers finden Sie unter Speicherverwaltung.

Absolute Adressen

Sie können eine neue Variable an der Adresse erstellen, an der bereits eine Variable existiert. Geben Sie dazu in der Deklaration der neuen Variable nach dem Namen des Typs die Direktive absolute und danach den Namen einer vorhandenen (bereits deklarierten) Variable an. Beispiel:

 var
    Str: string[32];
    StrLen: Byte absolute Str;

Diese Anweisung legt fest, dass die Variable StrLen an derselben Adresse wie die Variable Str beginnt. Da das erste Byte eines kurzen Strings dessen Länge angibt, ist der Wert von StrLen die Länge von Str.

Die Initialisierung einer Variablen in einer absolute-Deklaration und die Kombination von absolute mit anderen Direktiven ist nicht zulässig.

Dynamische Variablen

Durch einen Aufruf der Prozedur GetMem oder New können Sie dynamische Variablen erzeugen. Diese Variablen werden auf dem Heap zugewiesen und nicht automatisch verwaltet. Die Freigabe des für eine dynamische Variable reservierten Speichers liegt in der Verantwortung des Programmierers. Variablen, die mit GetMem erzeugt wurden, müssen mit FreeMem freigegeben werden. Variablen, die mit New erzeugt wurden, müssen mit Dispose freigegeben werden. Weitere Standardroutinen zur Verwaltung von dynamischen Variablen sind ReallocMem, AllocMem, Initialize, Finalize, StrAlloc und StrDispose.

Lange Strings, WideStrings, dynamische Arrays, Varianten und Interfaces werden auf dem Heap zugewiesen. Ihr Speicher wird aber dennoch automatisch verwaltet.

Thread-Variablen

Thread-Variablen (oder Thread-lokale Variablen) finden in Multithread-Anwendungen Verwendung. Eine Thread-Variable entspricht in etwa einer globalen Variablen, die einzelnen Ausführungs-Threads erhalten jedoch eine eigene, private Kopie der Variablen, auf die andere Threads keinen Zugriff haben. Thread-Variablen werden nicht mit var, sondern mit threadvar deklariert. Beispiel:

 threadvar X: Integer;

Die Deklaration einer Thread-Variablen

  • darf nicht innerhalb einer Prozedur oder Funktion erfolgen.
  • darf keine Initialisierungen enthalten.
  • darf nicht die Direktive absolute enthalten.

Dynamische Variablen, die normalerweise vom Compiler verwaltet werden (lange Strings, Strings des Typs WideString, dynamische Arrays, Varianten und Interfaces), können mit der Direktive threadvar deklariert werden. Der Compiler gibt aber den auf dem Heap belegten Speicher (der von den einzelnen Ausführungs-Threads reserviert wird) nicht automatisch frei. Wenn Sie diese Datentypen in Thread-Variablen verwenden, müssen Sie selbst für die Freigabe des Speichers innerhalb des Threads sorgen, bevor dieser beendet wird. Beispiel:

 threadvar S: AnsiString;
 S := 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
   ...
 S := '';  // Freigabe des von S belegten Speichers

Anmerkung:  Die Verwendung solcher Konstrukte wird nicht empfohlen.

Sie können Varianten freigeben, indem Sie ihnen den Status Unassigned zuweisen. Um Interfaces oder dynamische Arrays freizugeben, weisen Sie ihnen den Wert nil zu.

Siehe auch