GNU-Pascal in Beispielen: Variablen und Typen

Aus Wikibooks
Zur Navigation springen Zur Suche springen

zurück zu GNU-Pascal in Beispielen

Variablen und Typen[Bearbeiten]

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

Variablendeklarationen[Bearbeiten]

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[Bearbeiten]

 program Initialisieren;
 
 var
   Text1: String (10) = 'Hallo,';
   Text2: String (10) Value 'Welt';
   Text3: String (10);
 
 begin
   Text3 := '!';
   WriteLn (Text1, ' ', Text2, Text3)
 end.

Erklärung[Bearbeiten]

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[Bearbeiten]

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

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[Bearbeiten]

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

Ganze Zahlen[Bearbeiten]

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[Bearbeiten]

Das folgende Programm demonstriert die Grundrechenarten mit ganzen Zahlen:

Programm: Rechnen[Bearbeiten]
 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[Bearbeiten]

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 ein Ergebnis von liefern würde, dieses Ergebnis aber nicht in eine Variable vom Typ Integer passt muss die "geteilt durch"-Operation durch Div ersetzt werden. ist bei ganzen Zahlen 3 Rest 1. Den Rest erhalten wir durch den Operator Mod.

Fließkommazahlen[Bearbeiten]

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 [3].

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[Bearbeiten]
 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[Bearbeiten]

Es werden zwei Fließkommazahlen deklariert, wobei eine mit dem Umrechnungskurs von Euro nach D-Mark initialisiert [4] 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 DM. Wünschenswert wäre eine Anzeige, die uns zwei Nachkommastellen gerundet ausgibt:

Programm: Eurorechner 2[Bearbeiten]
 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[Bearbeiten]

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[Bearbeiten]
 program Runden;
 
 begin
   WriteLn ('2.7 gerundet      = ', Round (2.7));
   WriteLn ('2.7 abgeschnitten = ', Trunc (2.7))
 end.
Erklärung[Bearbeiten]

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

Zeichenketten[Bearbeiten]

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[Bearbeiten]
 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[Bearbeiten]

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[Bearbeiten]
 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[Bearbeiten]

Die Prozedur [5] 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 [6]. 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[Bearbeiten]
 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[Bearbeiten]

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 [7] 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 [8]. 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 [9], die man ermitteln kann:

Programm: Zahlencodes[Bearbeiten]
 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[Bearbeiten]

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[Bearbeiten]

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 .

Programm: BoolTest[Bearbeiten]
 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[Bearbeiten]

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

Programm: Aufzaehlung1[Bearbeiten]
 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[Bearbeiten]

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[Bearbeiten]

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[Bearbeiten]
 program Unterbereich;
 
 var
   KleinBuchstaben: 'a'..'z';
   Ziffern: 0..9;
   
 begin
   Ziffern := 5;
   WriteLn (Ziffern, '  ', Succ (Ziffern))
 end.
Erklärung[Bearbeiten]

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[Bearbeiten]

Arrays [10] 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[Bearbeiten]
 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[Bearbeiten]

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[Bearbeiten]
 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[Bearbeiten]

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 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[Bearbeiten]
 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[Bearbeiten]

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 ().

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 Felder großes TicTacToe[11]-Spielfeld initialisiert wird:

Programm: Array4[Bearbeiten]
 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[Bearbeiten]

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[Bearbeiten]
 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[Bearbeiten]

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[Bearbeiten]

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[Bearbeiten]
 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[Bearbeiten]

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[Bearbeiten]

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

  • +, Vereinigung, : Dieser Operator bildet die Vereinigung beider Mengen. Beispiel:
['a', 'b'] + ['c', 'd'] = ['a', 'b', 'c', 'd']
  • *, Durchschnitt, : 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 : Bildet eine Menge, die aus nicht gemeinsamen Elementen besteht. Beispiel:
['a', 'b'] >< ['b', 'c'] = ['a', 'c']
  • -, Differenz, : 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, : 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, : 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, : Ist True, wenn A dieselben Elemente enthält wie B. Beispiel:
['a', 'b'] = ['a', 'b']
  • <>, Ungleich, : Ist True, wenn A verschieden von B ist. Beispiel:
['a', 'b'] <> ['a', 'b', 'c']
  • in, Enthalten, : 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[Bearbeiten]

  1. ä, ü, ö und ß gelten in diesem Zusammenhang nicht als Buchstaben
  2. Bei manchen reservierten Worten ist es durchaus erlaubt, diese als Bezeichner zu verwenden. Im Sinne der Lesbarkeit von Programmen sollten Sie auf dieses Feature verzichten.
  3. Falls Zahlen mit nahezu beliebiger Genauigkeit benötigt werden, so kann die Unit "GMP" eingebunden werden. Auf Units und Module wird in einem gesonderten Kapitel eingegangen.
  4. Diese Variable sollte besser eine Konstante sein. Mehr über Konstanten im Kapitel Konstanten.
  5. Auf Details zu Prozeduren, Funktionen und Routinen gehen wir in einem späteren Kapitel ein. Bisher reicht die Definition, dass all diese Bezeichnungen für Ausdrücke stehen, die etwas bewirken.
  6. Diese Art der Formatierung kennen Sie bereits aus dem Abschnitt über Fließkommazahlen
  7. Diese Art der Übergabe bezeichnet man als "Call-By-Reference". Mehr darüber im Kapitel "Call by Reference"
  8. Beispielsweise übernehmen die Tasten Tabulator, Backspace und Enter nur Steueraufgaben.
  9. Gebräuchlich sind dabei die so genannten ASCII- oder ANSI-Codes.
  10. Andere Bezeichnungen für Array sind "Vektor" und "Feld"
  11. Ein Spiel, bei dem es darum geht, drei gleiche Steine in eine Reihe zu legen wobei nacheinander gesetzt wird.


Wikibooks buchseite.svg Zurück zu Einstieg in GNU-Pascal | One wikibook.svg Hoch zu Inhaltsverzeichnis | Wikibooks buchseite.svg Vor zu Konstanten