Basic lernen (Einleitung, Vorbereitungen, Kapitel 1, 2, 3, 4, 5, 6)

Operatoren, SUBs und Funktionen, Arrays

4.1; Operatoren:

Bereits mehrfach verwendet haben wir Operatoren stillschweigend verwendet, doch genau erklärt habe ich sie noch nicht. Dem möchte ich nun nachkommen. Die Bezeichnung "Operator" kommt daher, da ein Operator mit Daten (den Operanden) "operiert", dh. diese verwendet. Eine Übersicht über Operatoren in Basic:

Operator Bedeutung Erläuterung Beispiel(e)
= Ist-Gleich Zuweisung oder Vergleich auf Gleichheit a = 2
a = b
< Kleiner Vergleich auf Wert - ob kleiner a < b
> Größer Vergleich auf Wert - ob größer a > b
<= Kleiner-Gleich Wenn Wert kleiner oder gleich [rechter Operand] Aussage wahr a <= b
>= Größer-Gleich Wenn Wert größer oder gleich [rechter Operand] Aussage wahr a >= b
- Minus Subtrahieren a = b - 2
+ Plus Addieren a = b + 2
* Mal Multiplizieren a = b * 2
/ Dividieren Dividieren a = b / 2

Ein kleines Beispiel hierzu:

CLS
a = 2
PRINT "Der Wert der Variable a beträgt:"; a
INPUT "Welcher Wert soll a zugewiesen werden. (3 hat Ausgabe zur Folge) ", a
IF a = 3 THEN PRINT "a hat den Wert:"; a
a = a * 5
PRINT "Der Wert von a wurde verfünffacht und beträgt nun:"; a

4.2; SUBs und Funktionen:

Immer wieder wird ein bestimmter Code mehrmals benötigt. Solcher Code lässt sich in Basic in einem SUB (bezeichnet man in anderen Programmiersprachen als Prozedur) zusammenfassen. Der Aufbau eines SUBs sieht folgendermaßen aus:

SUB Name
Anweisung 1
Anweisung 2
Anweisung 3
...
END SUB

Die Anweisungen (hier mit 1 bis 3 bezeichnet) werden ausgeführt, nachdem der SUB ausgeführt wurde. Es ist vollkommen gleichgültig, ob die Anweisungen, die ausgeführt werden sollen, in einem SUB untergebracht werden, oder "normal" im Programm hingeschrieben werden. Letzteres erfordert jedoch einiges mehr an Tipparbeit, da derselbe Code immer wieder geschrieben werden muss, weil er öfters benötigt wird.

Einfach so in den Quellcode können Sie die SUB-Definition jedoch nicht verfrachten. Sie muss nach dem eigentlichen Quellcode folgen. Der eigentliche Quellcode wird mit END abgeschlossen (siehe nächstes Beispiel)

Tipp: Übrigens dient END auch als Befehl, um das Programm zu beenden!

Vorletzte Anweisung
Letzte Anweisung
END

SUB Name
Anweisung 1
Anweisung 2
Anweisung 3
...
END SUB

Es lässt sich erkennen, dass SUBs nach dem Quellcode folgen müssen. Name bezeichnet hierbei den Namen des SUBs, der aufgerufen werden soll. Allerdings macht uns hier QBasic einen Strich durch die Rechnung. Sobald man nach dem END SUB sowie den Namen schreibt landet man in einem (fast) leeren Editorfenster. Die Grundstruktur des SUBs ist bereits eingetragen. Es müssen lediglich die Programmierzeilen hinzugefügt werden. Wie gelangen wir nun wieder zum Quellcode unseres Programmes? (angezeigt bekommen wir zu diesem Zeitpunkt immer noch den Quellcode des SUBs) Klicken Sie in QBasic auf "Ansicht" und darauffolgend auf "SUBs". Nun wählen Sie die erste Zeile in der Liste aus. Dies ist normalerweise der Namen, unter dem Sie Ihr Programm abgespeichert haben. Wenn es noch nicht gespeichert wurde, wird "Unbenannt" angezeigt. Ürigens können Sie auch einen SUB hinzufügen, indem Sie auf "Bearbeiten" und "Neuer SUB" klicken. Darauffolgend geben Sie den Namen des SUBs ein, danach zeigt der Editor wiederum nur den Quelltext des SUBs an. Aufgerufen werden kann ein SUB einfach, indem man seinen Namen im Quellcode anbringt.

Subname

Das nächste Beispiel demonstriert einen Verwendung von SUBs. Der Sinn des Beispiels liegt darin, Potenzen von Zahlen zu berechnen. Das Beispiel besteht aus 2 Teilen: 1. Teil: Eigentlicher Quellcode, 2. Teil: SUB. Den 1. Teil tippen Sie normal ab, den SUB (2. Teil) fügen Sie wie oben beschrieben durch Klicken auf "Ansicht" und "Neuer SUB" hinzu. Beachten Sie, dass Sie als Name für den SUB "berechnen" verwenden müssen. Sie können natürlich auch einen anderen Namen verwenden, aber das hätte zur Folge, dass Sie den eigentlichen Quellcode dementsprechend anpassen müssten. (eigentlich nur eine Änderung in einer Zeile)

CLS
INPUT "Basis: ", basis
INPUT "Exponent: ", exponent
CALL berechnen (basis, exponent)

Und der SUB:

SUB berechnen (bas, expo)
ergebnis = 1
FOR i = 1 TO expo
  ergebnis = ergebnis * bas
NEXT i
PRINT ergebnis
END SUB

Einige "Eigenarten" wurden bisher nicht geklärt. Der SUB verwendet Parameter, zwei um genau zu sein. Diese stehen in Klammer. Die Werte der Variablen basis (1. Parameter) und exponent (2. Parameter) werden an den SUB berechnen übergeben. Der Sinn von Parametern liegt also in der Wertübergabe. Wir müssen die eingegebenen zwei Werte an den SUB übergeben, da dieser mit denen weiterarbeiten muss. Da wir Parameter verwenden, muss der Aufruf mit CALL erfolgen.

Was SUBs jedoch nicht können, ist Werte zurückliefern. Angenommen, man schreibt einen mathematische Funktion, deren Aufgabe es ist, irgendeine Berechnung durchzuführen. Die Berechnung durchführen kann eine SUB durchaus, aber was mit dem Ergebnis? Ausgeben? Das vorherige Beispiel macht genau das. Doch was, wenn das Ziel eine Weiterverarbeitung ist? Hierzu benötigt man eine Funktion. Sie erfüllt genau denselben Zweck wie ein SUB, bietet jedoch einen kleinen Zusatz an: Sie kann Werte zurückliefern. Schauen Sie sich einmal folgende Anweisung an:

endergebnis = berechnen (basis, exponent)

Nehmen Sie einfach an, berechnen sei nun eine Funktion und würde nur das Endergebnis berechnen. Der Wert wird nicht ausgegeben. Der Vorgang läuft nun wie bei einer Zuweisung üblich von rechts nach links ab. Zuerst wird die Funktion berechnen aufgerufen, und als Parameter werden basis und exponent an sie übergeben. Die Funktion berechnen das Ergebnis und liefert es zurück. Das Ergebnis wurde zurückgeliefert und wird in der Variable endergebnis gespeichert.

Die Syntax einer Funktion sieht folgendermaßen aus:

FUNCTION Name
DO
Anweisung 1
Anweisung 2
Anweisung 3
...
LOOP
Name = Rueckgabewert
END FUNCTION

"Name" bezeichnet den Namen der Funktion. Anstelle eines Rückgabewertes kann natürlich auch ein Variablenbezeichner angegeben werden. Den Wert (bzw. der Wert der Variable) liefert die Funktion zur Weiterverarbeitung zurück.

Arrays:

(Um gleich ein Beispiel zu nennen..) Angenommen, ein Lehrer benötigt 60 Variablen, denn sein Vorhaben ist es, zu einer Klasse alle Namen der Schüler + deren Noten aufzunehmen. Die Klasse hat 30 Schüler, demnach benötigen wir 30 String-Variablen um die Namen der Schüler abzuspeichern sowie 30 Integer-Variablen um die Noten abzuspeichern. Wir könnten als Variablen-Bezeichner für die Namen der Schüler deren Vornamen nehmen und bei den Bezeichnern für die Variablen zum Abspeichern der Noten könnten wir den Vornamen des Schülers + Unterstrich + "note" verwenden. (z.B. "andreas_note")

Nun stehen wir vor (mindestens) 2 Problemen. Erstens wäre es für den Lehrer sicher auch praktisch, wenn er alle Namen + Noten auf einmal in einer Liste ausgeben könnte und um das zu erreichen, ist sehr viel Tipparbeit nötig. Die viele Tipparbeit ist zugleich unser zweites Problem.

Abhilfe schafft hier ein Array. (auch als Datenfeld oder Matrix bezeichnet) Ein Array beinhaltet (fast) beliebig viele Variablen gleichen Typs. Stellen Sie sich einfach vor, wir hätten 4 Variablen vom Typ Integer. (Ganzzahlentyp) Diese fassen wir quasi zusammen. Die einzelnen Werte bleiben natürlich erhalten. Auf alle 4 Variablen greifen wir nach einem bestimmten Schema zu. Das Schema sieht so aus: Arraybezeichner[Index]. Der Index reicht von 0 bis 3 und bezeichnet eine der 4 Variablen. Der Arraybezeichner ist der Name des Arrays. Nehmen wir als Bezeichner datensatz an. Wir wollen nun auf die zweite Variable zugreifen, also: datensatz[1]. Beachten Sie, dass bei 0 zu Zählen begonnen wird, deshalb hat die zweite Variable den Index 1.

Um wieder zur Praxis zurückzukehren. Ein Array wird folgendermaßen vereinbart:

DIM Name (Von TO Bis) AS Typ

Um gleich ein Beispiel zu nennen:

DIM datensatz (0 TO 3) AS Integer

Im obigen Beispiel wurde das Array datensatz mit 4 Integer-Variablen deklariert.

Das sind:

  1. datensatz[0]
  2. datensatz[1]
  3. datensatz[2]
  4. datensatz[3]

Übrigens hätten wir als unteren Index auch 1 nehmen können. Dann würde sich das Feld von 1 bis 4 erstrecken. (wiederum 4 Variablen)

Zum Typ String gibt es eine Besonderheit zu nennen. Vereinbart man eine Variable vom Typ String, so kann diese Variable max. 255 Zeichen aufnehmen. (Was darüber geht wird abgeschnitten) Will man eine obere Grenze festlegen (Maximallänge; das heißt, was darüber geht wird abgeschnitten) so kann man das folgendermaßen:

DIM datensatz (0 TO 3) AS String * Maximallänge

Beispiel:

DIM zehnzeichen (0 TO 3) AS String * 10

Hier wurde das Array "zehnzeichen" mit 4 Elementen vom Typ String festgelegt. Eine Variable kann maximal einen String von 10 Zeichen aufnehmen.

Abschließend noch die Realisierung des Beispiels, das ganz zu Beginn gebracht wurde. Es demonstriert zugleich, wie auf das Array zugegriffen wird.

CLS
DIM namen (1 TO 30) AS String
DIM noten (1 TO 30) AS Integer
FOR i = 1 to 30
  PRINT i; ". Schüler..."
  INPUT "Name: ", namen[i]
  INPUT "Note: ", noten[i]
NEXT i
PRINT ""
PRINT "Alle Schülerdaten werden noch einmal ausgegeben..."
FOR i = 1 TO 30
  PRINT namen[i]; " - "; noten[i]
NEXT i


Vorheriges Kapitel Nächstes Kapitel