PureBasic: Variablen und Konstanten

Variablen sind einfach gesagt Datenspeicher. In ihnen können sowohl Zahlenwerte als auch Zeichenketten (Strings) zur späteren Benutzung gespeichert werden.

 ; Listing 3: Variablen
 
 EnableExplicit
 
 Define x.i
 Define y.i

 OpenConsole()
 
 x = 1
 PrintN(Str(x))
 
 x = 2
 PrintN(Str(x))
 
 y = x + 1
 PrintN(Str(y))
 
 y + 1
 PrintN(Str(y))
 
 Delay(2000)

Ausgabe:

1
2
3
4

Nachdem das Programm wie üblich kompiliert wurde, sieht man die Zahlen 1, 2, 3 und 4 untereinander ausgegeben. Neu sind die Variablen. Variablen funktionieren an sich ganz einfach: Man deklariert und definiert sie, d.h. man teilt dem Compiler mit, dass es nun eine neue Variable mit einem Bezeichner gibt und ihr wird automatisch vom Compiler Speicherplatz zugewiesen. Im Beispiel wurde mit Define x.i eine Variable namens x vom Typ Integer (.i; Ganzzahl) definiert.

In PureBasic haben alle Zahlenvariablen standardmäßig den Wert 0, Strings werden automatisch mit dem Leerstring ("") initialisiert. Das Schlüsselwort EnableExplicit zu Beginn erzwingt, dass alle Variablen vor ihrer Nutzung einmal mit Namen und Typ definiert werden müssen. Würde EnableExplicit weggelassen, könnten Variablen beliebig an jeder Stelle im Quellcode ohne das Schlüsselwort Define angelegt werden. Dies ist aber (z.B. durch Tippfehler) eine häufige Fehlerursache, deshalb ist es empfehlenswert, von Beginn an EnableExplicit zu nutzen.

Es ist ebenfalls möglich, mit Define x.i = 2 einer Variable gleich bei der Definition einen Wert zuzuweisen. Ebenfalls können mit Define.i x, y mehrere Variablen des gleichen Typs zusammen definiert werden.

Es ist zu beachten, dass Variablenbezeichner nicht mit Zahlen beginnen dürfen und keine Rechenoperatoren oder Sonderzeichen enthalten dürfen. Dazu zählen auch Umlaute und ähnliche Zeichen.

PrintN(Str(x)) gibt nun den Inhalt der Variable x, also 1, aus. Warum jedoch muss man schreiben Str(x)? Wenn man sich an Listing 1 erinnert, wurde dazu erklärt, dass PrintN() immer einen String als Argument erwartet, jedoch keine Zahl, wie z.B. Delay(). Deshalb muss x zuvor in einen String umgewandelt werden, was Str() erledigt. Es fällt auf, dass PureBasic innere Ausdrücke vor äußeren auswertet (Str() vor PrintN()), genauso wie man es in der Grundschulmathematik bei der Klammersetzung gelernt hat. Des Weiteren kann man Variablen einen neuen Wert zuweisen. Dies geschieht auf die gleiche Weise wie bei der Initialisierung. Außerdem kann mit Variablen gerechnet werden, was man an der Zeile y = x + 1 sehen kann. Die Variable repräsentiert hierbei den Wert, der ihr zuvor zugewiesen wurde, in diesem Fall 2.

In PureBasic sind alle Standardrechenmethoden verfügbar:

• + für Addition
• - für Substraktion
• * für Multiplikation
• / für Division

Konstanten

Wie man sah, können Variablen dynamisch Werte zugewiesen werden. Es gibt aber auch Fälle, in denen man eine Konstante haben will, also einen Bezeichner für einen Wert, der sich nicht ändert.

 ; Listing 4: Konstanten
 
 #Vier = 4
 
 PrintN(Str(#Vier))
 Delay(2000)

Ausgabe:

4

In diesem Fall wurde die Konstante #Vier erzeugt (die Raute gehört zum Bezeichner!). Sie kann nachträglich nicht mehr geändert werden und repräsentiert in nachfolgenden Code den Zahlenwert 4. Ein nachträgliches #Vier = 5 würde also einen Compilerfehler erzeugen.

Es ist zwar prinzipiell freigestellt, welche Bezeichner man für Konstanten und Variablen wählt, jedoch gilt die Konvention, dass Konstanten groß geschrieben werden und Variablen klein. Dies dient der besseren Unterscheidung und macht den Code insgesamt lesbarer.

PureBasic verfügt über viele interne Konstanten, z.B. #Pi für die Kreiszahl. Andere stehen in der PureBasic-Referenz, wobei die meisten zu diesem Zeitpunkt noch verwirren können, da sie für verschiedene Befehle als Optionen zur Verfügung stehen oder zur Verarbeitung dieser.

Eingabe

Natürlich möchte man auch die Möglichkeit haben, Variablenwerte vom Benutzer des Programmes festlegen zu lassen. Man denke dabei z.B. an einen Taschenrechner.

 ; Listing 5: Benutzereingabe
 
 EnableExplicit

 Define x.i
 Define y.i

 OpenConsole()
 
 Print("1. Zahl: ")
 x = Val(Input())
 Print("2. Zahl: ")
 y = Val(Input())
 
 PrintN("x + y = " + Str(x + y))
 
 Delay(2000)

Ausgabe:

1. Zahl: 1
2. Zahl: 3
x + y = 4

In diesem Beispiel wurden wieder viele neue Dinge eingeführt. Was sieht man bei der Ausführung? Das Programm gibt den ersten String 1. Zahl: aus und wartet dann darauf das eine Zahl vom Benutzer eingegeben wird. Danach muss eine weitere Zahl eingegeben werden und zuletzt wird die Summe aus beiden ausgegeben.

Zuerst fällt auf, dass diesmal Print() und nicht PrintN() benutzt wird. Der Unterschied zwischen beiden liegt einzig und allein darin, dass Print() keinen Zeilenumbruch erzeugt, also die nächste Ausgabe auf die gleiche Zeile ausgegeben wird. Als nächstes ist der Befehl Input() neu. Er wartet, bis der Benutzer etwas eingibt und Enter drückt. Die Eingabe wird als String zurückgegeben, das bedeutet, man erhält von dem Befehl etwas (in diesem Fall einen String), mit dem man weiterarbeiten kann. Außerdem erzeugt Input() einen Zeilenumbruch nach der Eingabe.

Da wir jedoch einen Zahlenwert speichern wollen und keinen String, muss dieser nun in einen Zahlenwert umgewandelt werden. Dies geschieht mit dem Befehl Val(), der als Gegenstück zu Str() gesehen werden kann. Es ist natürlich auch möglich, einfach nur Enter zu drücken, wenn eine Eingabe erwartet wird, sodass ein leerer String (also "") zurückgegeben wird. Dieser wird bei der Umwandlung in einen Zahlenwert automatisch zu null.

Zuletzt fällt auf, dass die Zahlenoperation, das Addieren, direkt in den Str()-Befehl geschrieben wurde. Es wird also zuerst der Ausdruck in den Klammer ausgewertet, bevor der Befehl an sich ausgewertet wird. Dies gilt auch für alle anderen Befehle. Des Weiteren kann man Strings zusammenfügen, ebenfalls über +.