GNU-Pascal in Beispielen: Variablen und Typen

zurück zu GNU-Pascal in Beispielen

Variablen und Typen

Dieses Kapitel gibt einen Überblick über die Verwendung von Variablen und den dazugehörigen Typen.

Variablendeklarationen

Wie im ersten Kapitel angedeutet, werden Variablen innerhalb eines Bereiches deklariert, der mit var eingeleitet wird. Mehrere Variablen vom gleichen Typ werden durch Kommas voneinander getrennt aufgeführt.

Variablen haben, wenn sie auf diese Weise deklariert werden, einen zufälligen Wert. Man sollte sich wirklich nicht darauf verlassen, dass dieser Wert bei Variablen vom Typ Zahl immer Null und bei Zeichenkettenvariablen immer die leere Zeichenkette ist. Tatsächlich handelt es sich dabei um ein Abbild des Computerspeichers. Variablen kann man bei der Deklaration initialisieren, wobei es zwei alternative Schreibweisen gibt:

Programm: Initialisieren

program Initialisieren;

var
  Text1: String (10) = 'Hallo,';
  Text2: String (10) Value 'Welt';
  Text3: String (10);

begin
  Text3 := '!';
  WriteLn (Text1, ' ', Text2, Text3)
end.

Erklärung

Es werden drei Variablen deklariert, Text1, Text2 und Text3, allesamt vom Typ String (10). Die Variable Text1 wird mit dem Gleichheitszeichen und Text2 wird mit dem Schlüsselwort Value initialisiert. Text3 wird innerhalb des Programmkörpers ein Wert zugewiesen. Wertzuweisungen erfolgen immer mit :=

Variablennamen

Variablennamen dürfen grundsätzlich alle Kombinationen aus Buchstaben und Ziffern sein, sofern am Anfang des Wortes ein Buchstabe vorkommt und der Name selbst kein reserviertes Wort in Pascal ist .

Namen von Objekten, wie Programmen und Variablen, heißen auch "Bezeichner".

• Gültige Bezeichner: Name, Bezeichner, Nummer, Anzahl, Siebzehn, i, k1, Maus1, Programm, Beginne
• Ungültige Bezeichner: 1.Element, @Name, Müller, begin, program, GNU-Pascal

Der Unterstrich "_" darf auch vorkommen. Der Grund, weswegen an dieser Stelle auf Variablennamen aufmerksam gemacht wird ist folgende Regel: Namen von Bezeichnern sollten aussprechbar sein und eine Aussage haben. Es ergibt keinen Sinn im Sinne der Lesbarkeit von Programmen, wenn Variablen allesamt Bezeichner der Art k1, k2, k3, ... sind. Bezeichner sollten grundsätzlich mit großem Anfangsbuchstaben geschrieben werden. Bei zusammengesetzten Worten sollte jedes Teilwort mit großem Anfangsbuchstaben beginnen (z.B. AutoKennzeichen).

Vordefinierte Typen

Dieser Abschnitt befasst sich mit den in GNU-Pascal vordefinierten Typen.

Ganze Zahlen

Typen für ganze Zahlen werden grundsätzlich unterschieden in solche, die nur einen positiven Wertebereich haben (vorzeichenlos) und solche, deren Wertebereich auch negative Zahlen umfassen kann (vorzeichenbehaftet). Folgende Typen stehen zur Verfügung:

Vorzeichenbehaftet	Vorzeichenlos
ByteInt	ByteCard, Byte
ShortInt	ShortCard, ShortWord
Integer	Cardinal, Word
MedInt	MedCard, MedWord
LongInt	LongCard, LongWord

Falls nicht besondere Gründe dagegen sprechen, sollte immer Cardinal oder Integer benutzt werden.

Rechnen mit ganzen Zahlen

Das folgende Programm demonstriert die Grundrechenarten mit ganzen Zahlen:

Programm: Rechnen

program Rechnen;

var
  Zahl1, Zahl2, Ergebnis: Integer;

begin
  Zahl1 := 10;
  Zahl2 := 3;
  Ergebnis := Zahl1 + Zahl2;     { Ergebnis ist 13 }
  Ergebnis := Zahl1 - Zahl2;     { Ergebnis ist 7 }
  Ergebnis := Zahl1 * Zahl2;     { Ergebnis ist 30 }
  Ergebnis := Zahl1 Div Zahl2;   { Ergebnis ist 3 }
  Ergebnis := Zahl1 Mod Zahl2;   { Ergebnis ist 1 }
  WriteLn ('Ergebnis ist nun: ', Ergebnis)
end.

Erklärung

Zuerst werden vier Variablen für ganze Zahlen deklariert. Anschließend werden einige Rechenoperationen auf diese Variablen ausgeführt, die Ergebnisse dieser Operationen stehen in den Kommentaren neben den Zuweisungen. Da die Rechnung $10/3$ ein Ergebnis von $3,333333...$ liefern würde, dieses Ergebnis aber nicht in eine Variable vom Typ Integer passt muss die "geteilt durch"-Operation durch Div ersetzt werden. $10/3$ ist bei ganzen Zahlen 3 Rest 1. Den Rest erhalten wir durch den Operator Mod.

Fließkommazahlen

Fließkommazahlen sind solche, die Nachkommastellen haben. Der Operator "geteilt durch" ist so definiert, wie man es naiv erwarten würde. Fließkommazahlen sind immer vorzeichenbehaftet, sie unterscheiden sich untereinander in der Genauigkeit, die mit steigender Größe wächst .

Folgende Fließkommatypen stehen zur Verfügung

• Single,
• ShortReal,
• Real,
• Double,
• LongReal,
• Extended

Das folgende Beispiel implementiert einen einfachen Euro-Nach-DM Umrechner:

Programm: EuroRechner

program EuroRechner;

var
  EuroNachDM: Real Value 1.95583;
  Betrag: Real;

begin
  Write ('Wie viel Geld haben Sie in der Tasche? ');
  ReadLn (Betrag);
  WriteLn ('Sie hätten jetzt ', Betrag * EuroNachDM, ' DM')
end.

Erklärung

Es werden zwei Fließkommazahlen deklariert, wobei eine mit dem Umrechnungskurs von Euro nach D-Mark initialisiert wird. Ein einzugebender Euro-Betrag wird innerhalb der WriteLn-Anweisung nach DM umgerechnet. Ein Programmlauf offenbart allerdings eine Schwierigkeit:

Wie viel Geld haben Sie in der Tasche? 12.77
Sie hätten jetzt 2.497594910000000e+01 DM

Es sind zu viele Nachkommastellen und die Zahl selbst wird in einer schlecht lesbaren Notation angezeigt. Es handelt sich dabei um den Betrag $2.4976*10^{1}$DM. Wünschenswert wäre eine Anzeige, die uns zwei Nachkommastellen gerundet ausgibt:

Programm: Eurorechner 2

program EuroRechner2;

var
  EuroNachDM: Real Value 1.95583;
  Betrag: Real;

begin
  Write ('Wie viel Geld haben Sie in der Tasche? ');
  ReadLn (Betrag);
  WriteLn ('Sie hätten jetzt ', Betrag * EuroNachDM : 0 : 2, ' DM')
end.

Erklärung

Die gewünschte Ausgabe erhalten wir durch Formatangaben in der WriteLn-Anweisung:

 Wie viel Geld haben Sie in der Tasche? 12.77
 Sie hätten jetzt 24.98 DM

Die Zahl nach dem ersten Doppelpunkt bedeutet die gesamte Anzahl von Stellen, einschließlich des Punktes und der Nachkommastellen. Gibt man hier eine "0" ein, so bedeutet das eine beliebige Anzahl von Vorkommastellen. Egal wie groß die Zahl ist, sie wird immer korrekt dargestellt. Die Zahl nach dem zweiten Doppelpunkt bedeutet die Anzahl der Nachkommastellen. Anstelle konkreter Zahlen dürfen hier auch Variablen vom ganzzahligen Typ eingesetzt werden.

Manchmal ist es nötig, eine Fließkommazahl in eine ganze Zahl zu überführen. Hierzu stehen zwei Funktionen zur Verfügung:

Programm: Runden

program Runden;

begin
  WriteLn ('2.7 gerundet      = ', Round (2.7));
  WriteLn ('2.7 abgeschnitten = ', Trunc (2.7))
end.

Erklärung

Ist der Abstand einer Zahl zur nächsten ganzen Zahl kleiner oder gleich $0.5$, so rundet die Funktion Round auf, sonst ab. Trunc hingegen entfernt die Nachkommastellen, rundet also immer ab.

Zeichenketten

In Kapitel Einstieg in GNU Pascal wurde bereits ein einführendes Beispiel zum Umgang mit Strings gezeigt, so dass wir hier darauf verzichten werden und uns den fortgeschrittenen String-Techniken widmen können.

Programm: StringTest

program StringTest;

var
  Text: String (1000);
  TextLaenge: Integer;

begin
  Write ('Bitte geben Sie einen Text ein: ');
  ReadLn (Text);
  Text := 'Eingabe: ' + Text;
  TextLaenge := Length (Text);
  WriteLn ('''', Text, ''' ist ', TextLaenge, ' Zeichen lang.' )
end.

Erklärung

Ein String wird immer mit einer maximalen Länge deklariert, der so genannten "Kapazität". Gibt ein Anwender einen Text ein, so wird diese Zeichenfolge an die Zeichenkette "Eingabe:" gehängt. Dies geschieht mit dem +-Zeichen. Die gesamte Länge des Textes wird durch die Funktion Length ermittelt. Leider ist es nicht möglich, beliebig lange Zeichenketten aufzunehmen. Der größte Wert, den die Kapazität annehmen kann ist allerdings so groß wie die größte Zahl vom Typ Cardinal, so dass sie vermutlich immer genug Platz zur Verfügung haben.

Eine wesentlich elegantere Methode zum Erzeugen eines Strings aus verschiedenen Teilen besteht in der Verwendung einer auf diesen Zweck spezialisierten Funktion:

Programm: StringTest2

program StringTest2;

var
  GesamtText, Eingabe: String (1000);
  TextLaenge: Integer;

begin
  Write ('Bitte geben Sie einen Text ein: ');
  ReadLn (Eingabe);
  TextLaenge := Length (Eingabe);
  WriteStr (GesamtText, Eingabe : TextLaenge + 3, TextLaenge : 5);
  WriteLn (GesamtText)
end.

Erklärung

Die Prozedur WriteStr erlaubt es, den Text beim Aneinanderhängen zu formatieren. Hierbei wird auch gezeigt, wie Variablen als Formatangabe benutzt werden können. Der Text der Eingabe wird so formatiert, als habe er drei Zeichen mehr als er hat . Diese Zeichen werden mit Leerstellen aufgefüllt. Die Ausgabe der Textlänge wird mit einer Gesamtlänge von 5 Zeichen angegeben. Somit wird auch hier die niederwertigste Ziffer 5 Stellen eingerückt. Folgende zwei Programmläufe verdeutlichen das:

Bitte geben Sie einen Text ein: hallo welt
   hallo welt   10
Bitte geben Sie einen Text ein: Tag!
   Tag!    4

Enthält ein String eine Zahl, so kann es nötig sein diese in eine Zahl vom Typ Integer oder Real umzuwandeln. Gründe dafür könnten sein, dass mit dieser Zahl weitergerechnet werden soll oder eine Umwandlung bessere Darstellungsmöglichkeiten mit Hilfe von Formatangaben, wie wir sie oben besprochen haben, bietet

Programm StringNachZahl

program StringNachZahl;

var
  Zahlentext: String (20) = '1.234';
  Zahl: Real;
  Fehler: Integer;

begin
  Val (Zahlentext, Zahl, Fehler);
  WriteLn (Zahl : 0 : 2, '  Fehlermeldung= ', Fehler)
end.

Erklärung

Die Prozedur Val wandelt einen String in eine Fließkommazahl oder eine ganze Zahl, je nachdem, von welchem Typ das Argument ist. Tritt ein Fehler auf, weil der umzuwandelnde String keine Zahl repräsentiert, so wird die Variable Fehler auf einen Wert gesetzt der verschieden von 0 ist.

Der Typ Char dient dazu, genau ein Zeichen aufzunehmen. Zeichen müssen dabei nicht notwendigerweise druckbar sein sondern können auch Steueraufgaben übernehmen . Zeichen werden genauso gelesen und ausgegeben wie Strings, daher verzichten wir hier auf ein einführendes Beispiel. Zu jedem Zeichen gehört eine Repräsentation als Zahl im Bereich von 0 bis 255 , die man ermitteln kann:

Programm: Zahlencodes

program Zahlencodes;

var
  Buchstabe: Char;

begin
  Write ('Geben Sie einen Buchstaben ein: ');
  ReadLn (Buchstabe);
  WriteLn ('Zahlencode von ', Buchstabe, ' : ', Ord (Buchstabe));
  WriteLn ('Nächster Buchstabe: ', Chr (Ord (Buchstabe) + 1))
end.

Erklärung

Die Funktion Ord gibt zu jedem Buchstaben den dazugehörigen Zahlenwert zurück. Chr hingegen liefert den Buchstaben zu einem bestimmten Zahlenwert. Diese Zahlenwerte lassen sich addieren, damit liefert Chr (Ord (Buchstabe) + 1) den nächsten Buchstaben zurück.

Der Typ Boolean

Boolsche Werte gibt man üblicherweise nicht ein, man erhält sie aus bestimmten Abfragen. So liefert die Aussage $3<4$ den Wert „Wahr“. In GNU-Pascal wird dies repräsentiert durch True, das Gegenteil davon ist False. Nebenbei gilt False$<$True.

Programm: BoolTest

program BoolTest;

var
  Wahrheit: Boolean;

begin
  Wahrheit := 3 < 4;
  WriteLn (Wahrheit)
end.

Zu Boolschen Werten gehören die Operatoren not, and, or und xor mit folgenden Regeln:

A	B	not A	A and B	A or B	A xor B
True	True	False	True	True	False
True	False	False	False	True	True
False	True	True	False	True	True
False	False	True	False	False	False

Aufzählungstypen

Aufzählungstypen dienen dazu, eine bestimmte Wertemenge exakt festzulegen. Das könnten Spielkartenfarben sein oder Automarken.

Programm: Aufzaehlung1

program Aufzaehlung1;

var
  Farbe: (Rot, Gelb, Blau);

begin
  Farbe := Rot;
  WriteLn (Farbe = Rot, ' ', Farbe = Gelb, ' ', Farbe = Blau);
  Farbe := Succ (Farbe);
  WriteLn (Farbe = Rot, ' ', Farbe = Gelb, ' ', Farbe = Blau);
  Farbe := Pred (Blau);
  WriteLn (Farbe = Rot, ' ', Farbe = Gelb, ' ', Farbe = Blau);
  WriteLn ('Ord: ', Ord (Gelb));
end.

Erklärung

Die möglichen Werte werden bei der Deklaration in Klammern gesetzt. Ab da kann Farbe nur die Werte Rot, Gelb oder Blau annehmen. Die Funktion Succ gibt den Nachfolger und Pred den Vorgänger eines bestimmten Elementes an. Die Reihenfolge der Elemente der Aufzählung werden bei der Deklaration festgelegt. So ist Blau der Nachfolger von Gelb. Die Funktion Ord liefert die zahlenmäßige Entsprechung des Elementes. Man beachte, dass in der Informatik Numerierungen mit Null beginnen. Der Vorgänger von Rot und der Nachfolger von Blau sind nicht definiert.

Unterbereichstypen

Unterbereichstypen schränken einen möglichen Wertebereich ein. So ist der Typ Byte ein Unterbereich vom Typ Cardinal. Unterbereichstypen werden gebildet, indem die untere und die obere Grenze der Werte angegeben werden. Folgendes Beispiel verdeutlicht das:

Programm: Unterbereich

program Unterbereich;

var
  KleinBuchstaben: 'a'..'z';
  Ziffern: 0..9;

begin
  Ziffern := 5;
  WriteLn (Ziffern, '  ', Succ (Ziffern))
end.

Erklärung

KleinBuchstaben und Ziffern sind zwei Unterbereichstypen. Der Zahlenwert der unteren Grenze muss kleiner sein als der Zahlenwert der oberen Grenze. Die Funktionen Succ und Pred sind auch hier sinnvoll anwendbar.

Arrays

Arrays dienen zur Aufnahme einer Menge gleichartiger Werte. Die Menge der Werte wird bei der Deklaration in Form eines Typs angegeben, ebenso der Typ, der vom Array gespeichert wird.

Programm: Array1

program Array1;

var
  MeinArray: array [1..4] of Integer;

begin
  MeinArray[1] := 10;
  MeinArray[2] := 11;
  MeinArray[3] := 12;
  MeinArray[4] := 13
end.

Erklärung

Das Array MeinArray kann vier Werte aufnehmen, allesamt vom Typ Integer. Die Definition der Grenzen (1..4) erfolgt über einen Unterbereichstypen, der in eckige Klammern gesetzt wird. MeinArray[1] ist das erste Element des Arrays, die 1 hierbei ist der Index, der selbst zum Unterbereichstypen 1..4 passen muss. Das Array ist somit durchnummeriert, die einzelnen Elemente können genauso wie andere Variablen initialisiert werden.

Eine andere Art, Arrays zu deklarieren zeigt folgendes Beispiel:

Programm: Array2

program Array2;

var
  BoolArray: array [Boolean] of String (4);

begin
  BoolArray[False] := 'Nein';
  BoolArray[True]  := 'Ja';
  WriteLn ('Ist 4 kleiner als 2? ', BoolArray[4 < 2])
end.

Erklärung

Bei der Deklaration von BoolArray wird kein Unterbereichstyp, sondern ein aufzählbarer Typ verwendet, der False und True als mögliche Indizes anbietet. Der Inhalt des Arrays sind zwei Strings der Kapazität 4. Da $4<2$ falsch ist, schreibt die WriteLn-Anweisung den String, den BoolAray[False] enthält.

Eine Initialisierung des Arrays während der Deklaration sieht wie folgt aus:

Programm: Array3

program Array3;

var
  BoolArray: array [Boolean] of String (1) = ('', '0');
  Zufall: Integer;

begin
  Zufall := Random (20);
  WriteLn ('Zufallszahl := ', BoolArray[Zufall < 10], Zufall)
end.

Erklärung

Die beiden möglichen Werte des Arrays werden innerhalb der Klammer in aufsteigender Reihenfolge der Indizes initialisiert, also zuerst BoolArray[False]. Initialisiert wird dieses Array mit den beiden Werten "leerer String" und "0". Die Funktion Random liefert eine Zufallszahl zwischen 0 und 19 ($20-1$).

Die WriteLn-Anweisung schreibt alle Zufallszahlen zweistellig aus, wobei Zufallszahlen, die kleiner als 10 sind, um eine führende "0" (also BoolArray[True]) ergänzt werden. Falls die Zufallszahl größer oder gleich 10 ist, so wird der leere String ergänzt, der sich nicht bemerkbar macht.

Mehrdimensionale Arrays, wie sie bei Spielen oder in der Mathematik auftauchen, werden von GNU-Pascal ebenfalls unterstützt. Im folgenden zeigen wir, wie ein $3*3$ Felder großes TicTacToe-Spielfeld initialisiert wird:

Programm: Array4

program Array4;

var
  TicTacToe: array [1..3, 1..3] of (Schwarz, Weiss, Frei);

begin
  { Spielfeld initialisieren }
  TicTacToe[1, 1] := Frei;
  TicTacToe[1, 2] := Frei;
  TicTacToe[1, 3] := Frei;
  TicTacToe[2, 1] := Frei;
  TicTacToe[2, 2] := Frei;
  TicTacToe[2, 3] := Frei;
  TicTacToe[3, 1] := Frei;
  TicTacToe[3, 2] := Frei;
  TicTacToe[3, 3] := Frei
end.

Erklärung

Mehrdimensionale Arrays werden deklariert, indem die einzelnen Dimensionen durch Kommas getrennt angegeben werden. Bei der Initialisierung verfährt man genauso.

Auch Strings kann man als Arrays auffassen. Das folgende Programm demonstriert, wie der erste Buchstabe ausgewertet wird:

Programm: StrArray

program StrArray;

var
  Wort: String (100);

begin
  Write ('Bitte geben Sie ein Wort ein: ');
  ReadLn (Wort);
  WriteLn ('Der erste Buchstabe des Wortes ''', Wort, ''' lautet: ', Wort[1])
end.

Erklärung

Die Deklaration des Strings kennen Sie bereits. Neu ist, dass Wort auch gleichzeitig ein eindimensionales Array darstellen kann, welches aus Zeichen besteht. Mit Wort[1] wird auf das erste Zeichen des Strings zugegriffen. Um auf das letzte Zeichen zuzugreifen, müssten wir Wort[Length (Wort)] schreiben. Später im Buch erfahren Sie, wie man alle Zeichen eines Wortes durchläuft.

Mengen

Mengen fassen Elemente vom gleichen Typ zusammen. Eine Menge ist mindestens leer und hat eine abzählbare Anzahl von Elementen. Als Basistypen kommen alle in diesem Kapitel beschriebenen, Typen in Frage außer den Fließkommazahlen.

Programm: Menge1

program Menge1;

var
  MeineMenge: set of Char;

begin
  MeineMenge := ['a'..'z', 'B', 'C'];
  WriteLn ('Anzahl der Elemente in der Menge= ', Card (MeineMenge));
  WriteLn ('Ist ''A'' in MeineMenge enthalten? ', 'A' in MeineMenge);
  WriteLn ('Ist ''a'' in MeineMenge enthalten? ', 'a' in MeineMenge)
end.

Erklärung

Eine Menge wird deklariert, indem der Basistyp angegeben wird, auf den diese Menge aufbaut. In unserem Beispiel ist es eine Menge verschiedener Zeichen. Die Menge wird initialisiert, indem alle Elemente angegeben werde, sei es implizit durch einen Bereich 'a'..'z', explizit durch die Angabe der einzelnen Elemente oder gemischt wie in obigem Beispiel. Wichtig ist, dass die Elemente in eckigen Klammern angegeben werden. Die Anzahl der Elemente in MeineMenge wird mit der Funktion Card ermittelt. Für unser Beispiel liefert sie 28 (Anzahl der Kleinbuchstaben plus zwei Großbuchstaben). Für die Menge

MeineMenge := ['A', 'B', 'A', 'C', 'A']

würde Card nur 3 liefern, da genau drei verschiedene Elemente in der Menge verfügbar sind. Bei leeren Mengen gibt Card 0 zurück. Ob ein Zeichen in der Menge enthalten ist oder nicht liefert uns der Operator in. Da 'A' nicht in MeineMenge enthalten ist, liefert die erste Abfrage False, die Zweite True.

Mengenoperatoren

Im folgenden werden die Operatoren, die auf Mengen angewendet werden können, vorgestellt:

• +, Vereinigung, $A\cup B$: Dieser Operator bildet die Vereinigung beider Mengen. Beispiel:

['a', 'b'] + ['c', 'd'] = ['a', 'b', 'c', 'd']

• *, Durchschnitt, $A\cap B$: Bildet den Durchschnitt beider Mengen, also eine Menge mit nur den Elementen, die in beiden Mengen vorkommen. Beispiel:

['a', 'b'] * ['b', 'c'] = ['b']

• ><, Symmetrische Differenz $A\times B$: Bildet eine Menge, die aus nicht gemeinsamen Elementen besteht. Beispiel:

['a', 'b'] >< ['b', 'c'] = ['a', 'c']

• -, Differenz, $A\setminus B$: Bildet eine Menge, die aus Elementen besteht welche nicht in der zweiten Menge vorkommen.Beispiel:

['a', 'b', 'c', 'd'] - ['b', 'c'] = ['a', 'd']

• <, echte Teilmenge, $A\subset B$: Ist True, wenn A eine echte Teilmenge von B ist, also alle Elemente aus A in B enthalten sind aber nicht umgekehrt. Beispiel:

['a', 'b'] < ['a', 'b', 'c']

• <=, Teilmenge, $A\subseteq B$: Ist True, wenn A eine Teilmenge von B ist, also alle Elemente aus A in B enthalten sind oder die Mengen sogar gleich sind. Beispiel:

['a', 'b'] <= ['a', 'b', 'c']

• =, Gleichheit, $A=B$: Ist True, wenn A dieselben Elemente enthält wie B. Beispiel:

['a', 'b'] = ['a', 'b']

• <>, Ungleich, $A\not =B$: Ist True, wenn A verschieden von B ist. Beispiel:

['a', 'b'] <> ['a', 'b', 'c']

• in, Enthalten, $x\in A$: Ist True, wenn x in A enthalten ist. x muss dabei dem Basistyp der Menge entsprechen. Beispiel:

'a' in ['a', 'b']

Im Kapitel über Kontrollstrukturen wird demonstriert, wie eine Menge zur Anzeige aller ihrer Elemente durchlaufen werden kann.

Anmerkungen

Zurück zu Einstieg in GNU-Pascal | Hoch zu Inhaltsverzeichnis | Vor zu Konstanten