Pascal-Tutorial (Vorwort, Installation, Kapitel 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)

Variablen und Konstanten, Zuweisung

In diesem Kapitel:

Letzte Aktualisierung: 12. Jänner 2009

2.1. Variablen und Konstanten

Bevor wir uns mit der Ein- und Ausgabe beschäftigen, müssen wir zunächst einmal wissen, wie wir Werte abspeichern. Angenommen, der Benutzer soll seinen Namen eingeben (wozu auch immer). Der Benutzer gibt seinen Namen ein, doch was dann? Wohin mit den eingegebenen Daten? Klar ist, dass diese irgendwo gespeichert werden müssen.

Entweder speichern wir die Daten im Arbeitsspeicher oder schreiben sie in eine Datei. Extra wegen einer Eingabe eine Datei anzulegen ist unpraktisch und schafft zusätzliche Probleme. Z.B.: Wenn Sie Ihr Programm von CD-ROM laufen lassen, können Sie auf diese keine Daten schreiben - das Programm funktioniert nicht mehr richtig oder gar nicht mehr. Daher werden wir Daten - sofern es keine größeren Datenmengen sind - immer im Arbeitsspeicher (RAM = Random Access Memory) ablegen.

Will man Daten im Arbeitsspeicher deponieren, muss man sich entscheiden, ob man dies in einer Variable oder in einer Konstante tun will. Aus technischer Sichtweise erfolgt die Speicherung auf die gleiche Art.

Variablen sind Ihnen sicher aus der Mathematik bekannt. Hier stehen sie als Platzhalter für Werte. Ähnlich ist es in der Programmierung. Hier reserviert eine Variable lediglich einen Bereich im Arbeitsspeicher. Wie groß der reservierte Bereich ist, hängt vom Typ der Variable ab. Ebenso gibt der Typ an, welche Werte eine Variable speichern kann.

So gibt es Typen, die die Speicherung von Ganzzahlen vorsehen (wie 3, -10 oder 4089), aber auch solche für Fließkommazahlen (z.B. 3.45435, -104589.3; der Punkt . dient als Dezimalkomma, und nicht - wie im deutschsprachigen Raum üblich - der Beistrich ,). Wenn Sie eine Variable angelegt (deklariert) haben, können Sie in dieser einen Wert speichern, und natürlich auch wieder auslesen.

Eine Konstante ist eine Variable mit festem Wert. Eine Konstante kann von einem bestimmten Typ sein, was aber nicht zwingend notwendig ist. Legt man eine Konstante an, muss man dieser gleich einen Wert zuweisen. Sie können den Wert der Konstante später bei Bedarf wieder auslesen, können ihn aber nicht mehr ändern (sonst wär's ja keine Konstante)! Damit verhindern Sie, dass der Wert - unabsichtlich (z.B. ein Programmierfehler könnte Auslöser dafür sein) - wieder überschrieben wird.

Sie könnten Konstanten z.B. verwenden, um Fehlermeldungen zu definieren. So definieren Sie an zentraler Stelle als ERR01 (beliebiger Name) den Fehler "Datei nicht gefunden." und können im restlichen Programm - auch mehrmals - auf ERR01 verweisen, um die Meldung auszugeben. Andere Beispiele sind - ohnehin - fixe Werte, z.B. in der Mathematik die Kreiszahl PI (3,14159265), Euler'sche Zahl e (2,71828183) oder Umrechnungsfaktoren (1 Zoll = 2.54 cm).

Bevor wir auf eine Variable zugreifen können, müssen wir diese dem Compiler bekannt geben. Diese Bekanntgabe bezeichnet man als Deklaration. Weisen wir einer Variable einen Wert zu, definieren wir sie.

Deklaration Bekanntgabe, z.B. dem Compiler bekannt geben, dass eine Variable existiert, welchen Bezeichner (Namen) sie trägt sowie von welchem Typ sie ist.
Definition Wertzuweisung, einer zuvor deklarierten Variable wird nun ein Wert zugewiesen.

Die Deklaration erfolgt - wie zu erwarten war - im Deklarationsteil des Programms. Sie sieht folgendermaßen aus:

VAR Name: Typ[Längenbegrenzung];

Anstelle von Name muss der Bezeichner (Name) der Variable angegeben werden. Der Name darf nur aus alphanumerischen Zeichen sowie dem Unterstrich _ bestehen. Alphanumerisch = A bis Z sowie 0 bis 9, egal ob Groß- oder Kleinschreibung bei den Buchstaben. Tipp: Der Name der Variable sollte so aussagekräftig wie möglich sein. Es ist für die Lesbarkeit besser, als Variablenbezeichner Vorname zu verwenden, als Variable14 oder vn. Ebenso unpraktisch wäre diesisteinehaeufigbenoetigtevariable, weil zu lang (Tipparbeit), nur schwer lesbar und wenig aussagekräftig.

Unterstriche können zur Lesbarkeit beitragen, aber dies_ist_eine_haeufig_benoetigte_variable macht's auch nicht viel besser. :-) Nach dem Variablenbezeichner folgt ein Doppelpunkt sowie der Typ der Variable. Als Typ kann einer der unten aufgezählten Typen angegeben werden. Die Längenbegrenzung ist optional und muss nicht vorhanden sein. Sie gibt an, wie lang der abgespeicherte Wert bei Variablen vom Typ String sein darf (das sind Zeichenketten mit n Zeichen).

Noch ein Hinweis zu VAR: Wenn Sie mehrere Variablen vom selben Typ vereinbaren möchten, dann trennen Sie die Variablen einfach durch Beistriche. Zum Beispiel:

VAR Variable1, Variable2: Integer;

Hier wurden die Variablen Variable1 und Variable2 vom Typ Integer vereinbart. Wollen Sie Variablen von unterschiedlichen Typen deklarieren, so müssen die Typen jeweils durch Strichpunkte getrennt werden. Ein Beispiel:

VAR Int1, Int2: Integer;
    Bool1, Bool2: Boolean;
    Str1, Str2, Str3: String;

Leicht zu erkennen ist, dass nur ein VAR benötigt wird. Deklariert werden 2 Variablen Int1 und Int2 vom Typ Integer, wieder 2 (Bool1 und Bool2) vom Typ Boolean und 3 Variablen vom Typ String (Str1, Str2 und Str3).

Kommen wir zu den Datentypen. Hierbei unterscheiden wir 3 Gruppen: Typen zur Ganzzahlenspeicherung, Typen zur Speicherung von Fließkommazahlen und solche zur Speicherung von Zeichenketten (Strings).

Ganzzahlentypen:

Typ Bereich Größe
ShortInt -128 bis 127 1 Byte
Byte 0 bis 255 1 Byte
Integer -32768 bis 32767 2 Bytes
Word 0 bis 65535 2 Bytes
LongInt -2147483648 bis 2147483647 4 Bytes

Gleitkommatypen:

Typ Bereich Größe
Single 1.5*10-45 bis 3.4*1038 4 Bytes
Real 2.9*10-39 bis 1.7*1038 6 Bytes
Double 5.0*10-324 bis 1.7*101308 8 Bytes
Comp 9.2*1018 8 Bytes
Extended 3.4*10-4952 bis 1.1*104952 10 Bytes

Zeichentypen:

Typ Bereich Größe
Char 0 bis 255; erweiterter ASCII-Zeichensatz 1 Byte
String bis zu 255 Zeichen bis zu 255 Bytes

Eine Ausnahme stellen noch boolesche Datentypen dar. Man müsste sie - ihrer internen Speicherung nach zu urteilen - eigentlich bei den Ganzzahlentypen einordnen.

Boolesche Typen:

Typ Größe
Boolean 1 Byte
ByteBool 1 Byte
WordBool 2 Bytes
LongBool 4 Bytes

Am häufigsten verwendet wird der Typ Integer, was die ganzzahlige Speicherung anbelangt. Sollte ein größerer Typ benötigt werden, kann LongInt verwendet werden. Die Größe gibt übrigens den Speicherplatzverbrauch im Arbeitsspeicher an. Eine LongInt-Variable benötigt doppelt soviel Speicherplatz wie eine Integer-Variable. Wie Ihnen sicher schon aufgefallen ist, gibt es Typen, die auch negative Zahlen (z.B. -10) speichern können und solche, die nur positive Werte speichern können. Der Vorteil von Datentypen, die nur positive Zahlen speichern, ist, dass bei gleichem Speicherverbrauch die obere Grenze höher liegt, also größere Zahlen gespeichert werden können. Um negative Zahlen darzustellen, wird das höchstwertigste Bit als Vorzeichenbit verwendet, es entfällt also, um Werte abzubilden.

Der am häufigsten verwendete Gleitkommatyp ist Real. Wichtig zu erwähnen ist, dass der Typ Comp KEINE Gleitkommazahlen speichern kann! Er speichert hingegen Ganzzahlen. Die Tatsache, dass der Typ Comp bei den Gleitkommatypen angeführt ist, lässt sich nur auf seine interne Speicherung zurückführen.

Der Typ Char speichert 1 Zeichen aus dem ASCII-Zeichensatz, z.B. das A, das x, 3, ein Fragezeichen ? usw. Der Typ String speichert hingegen bis zu 255 ASCII-Zeichen, z.B. Dieser Satz hier könnte in einem String gespeichert werden.

Boole'sche Wahrheitswerte sind Ihnen womöglich aus der Mathematik bekannt. Die beiden Zustände, die boolesche Typen speichern können, sind wahr und falsch. Intern erfolgt die Speicherung als 0 und 1. Das bedeutet, dass ein boolescher Datentyp nichts anderes als ein Ganzzahlentyp ist, der allerdings nur 0 und 1 speichern kann. Wenn Sie in Pascal eine boolesche Variable definieren möchten, können Sie dieser NICHT 0 oder 1 zuweisen, sondern nur TRUE (entspricht 1) oder FALSE (0).

Bisher noch nicht geklärt wurde die Deklaration von Konstanten. Sie sieht im Prinzip genauso aus wie die von Variablen, nur wird anstelle von VAR nun CONST verwendet. Und zusätzlich wird der Konstante gleich ein Wert zugewiesen:

CONST Name: Typ = Wert;

Beispielsweise die Deklaration (und zugleich natürlich auch Definition) der Konstante wahr vom Typ Boolean:

CONST wahr: Boolean = TRUE;

Versucht man nun, den Wert von wahr auf FALSE zu ändern, meldet der Compiler einen Fehler. Wie Sie das ausprobieren können (mit einer Zuweisung), siehe unten Kapitel 2.2.

Mehrere Konstanten vom selben Typ können nicht auf einmal deklariert werden!
Wie oben erwähnt, können auch typenlose Konstanten erzeugt werden:

CONST wahr = TRUE;

2.2. Zuweisung

Einer bereits deklarierten Variable kann man nach folgendem Schema einen Wert zuweisen:

Variable := Wert;

Der Wert, der auf der rechten Seite steht, wird nach links übertragen. Man sagt, er wird der Variable zugewiesen. Nach der Zuweisung hat die Variable den Wert, der rechts steht.

Angenommen, die Variable a sei vom Typ Integer und wurde zuvor deklariert. Mit der folgenden Zuweisung wird dieser Variable der Wert 70 zugewiesen.

a := 70;

Achten Sie darauf, dass der Zuweisungsoperator aus einem Doppelpunkt und einem Ist-Gleich-Zeichen besteht! In anderen Programmiersprachen ist das häufig nur ein =-Zeichen. Beachten Sie außerdem den Unterschied zur Deklaration/Definition von Konstanten. Um einer Konstante einen Wert zuzuweisen (siehe oben!), wird lediglich ein = (Ist-Gleich-Zeichen) verwendet, während bei "normalen" Zuweisungen := (Doppelpunkt und Ist-Gleich-Zeichen) benötigt wird!

Zuweisungen werden Ihnen im Laufe des Tutorials noch sehr häufig begegnen, darum begnüge ich mich an dieser Stelle mit einem Beispiel. Auf die Bedeutung von Operatoren werde ich später noch genauer eingehen.

Vorheriges Kapitel Nächstes Kapitel