Wer in den frühen Jahren der IT z.B. auf dem Commodore 64 in BASIC programmiert hat, der brauchte sich keine Gedanken um die Interna von Variablen und Konstanten zu machen. Es gab Variablen für Strings und Zahlen – und damit basta. Das hat sich mit modernen BASIC-Dialekten aus guten Gründen drastisch geändert.

Variablen belegen per se ein Stück zusammenhängenden Arbeitsspeicher (RAM) pro Stück. Aus heutiger Sicht ist es deshalb nicht effizient, für jede Variable eine gleich große Menge Arbeitsspeicher zu vergeuden. Manchmal möchte man nur mit sehr kleinen Zahlen arbeiten, ein andermal  mit Fließkommazahlen und wieder ein anderes Mal benötigt man Platz für sehr große Zeichenketten (Strings). Das ist der Punkt, an dem Datentypen ins Spiel kommen.

Wenn man für eine Variable immer nur so viel Speicher reserviert, wie tatsächlich gebraucht wird, dann verschwendet man weniger knappe Ressourcen (RAM) – aber es ergibt sich daraus noch ein weiterer Vorteil: Kleine Ganzzahlen werden vom Computer schneller verarbeitet, als z.B. große Fließkommazahlen.

Es ist auch unter BlitzBasic/AmiBlitz3 möglich, beim Schreiben von Programmen völlig darauf zu verzichten, sich mit Datentypen auseinanderzusetzen. Der Compiler geht dann intern einfach davon aus, dass er den Default-Datentyp verwenden soll. Unter AmiBlitz3 ist das QUICK (vergl. Anhang A – primitive Datentypen). Dieser Datentyp verbraucht entsprechend viel Ressourcen, da er ja groß genug für alle anfallenden Arten von Zahlen sein muss. Effizienter ist es da natürlich, sich die benötigte Größe der verwendeten Variablen vorher zu überlegen und sie mit einem passenden Datentyp zu deklarieren.

Variablen und ihr Datentyp

Eine Variable ist ein abstrakter Behälter für einen Wert, der bei der Ausführung eines Computerprogramms auftritt. Im Normalfall wird eine Variable im Quelltext durch einen Namen bezeichnet und hat eine Adresse im Speicher des Computers. Der durch eine Variable repräsentierte Wert (und gegebenenfalls auch die Größe) kann – im Unterschied zu einer Konstante – zur Laufzeit des Programms verändert werden. Variablen dienen also dazu, veränderbare Werte zu speichern.

Unter BlitzBasic/AmiBlitz3 definiert man eine Variable mittels des Schlüsselworts DEFTYPE nach dem folgenden Schema:

DEFTYPE .Datentyp Variablenname
; -- Beispiel, deklariert eine Variable vom Typ String: --
DEFTYPE .s altesKinderlied
altesKinderlied = "Alle meine Entchen"

Es ist auch mögliche, eine Variable direkt, ohne DEFTYPE zu deklarieren:

altesKinderlied.s = "Alle meine Entchen"

Der Variablenname ist im Rahmen syntaktischer Vorgaben frei wählbar. Er sollte aussagekräftig den Zweck der Variablen wiedergeben („sprechender“ Name). Erlaubt sind alphanumerische Zeichen und der Unterstrich mit den folgenden Ausnahmen:

• der Variablenname darf nicht gleichlautend mit einem Schlüsselwort sein.
• das erste Zeichen darf keine Ziffer sein.
• Umlaute sind nicht erlaubt.
• Sonderzeichen außer dem Unterstrich sind nicht erlaubt.
  Ausnahmen: Sonderzeichen, die zur Identifizierung eines Datentypen gehören, dürfen am Anfang oder Ende des Variablennamens verwendet werden.

Beispiele:

; Erlaubt:
meinString$, meinString.s
meine_variable1
aepfelZaehler

; Verboten:
mein$tring
1teVariable
äpfelZähler

Der Datentyp legt den Speicherverbrauch einer Variablen fest.

Primitive Datentypen

BlitzBasic/AmiBlitz3 verfügt über 7 Basis-Datentypen – die sogenannten primitiven Datentypen. Die Sprache verfügt auch über die Möglichkeit, aus diesen Typen erweiterte, die sogenannten zusammengesetzten Datentypen, zu erstellen – doch dazu später mehr.

Jedem primitiven Datentyp ist ein bestimmter Wertebereich zu eigen, in dessen Rahmen er Zahlen und Zeichen darstellen kann. Die Größe dieses Wertebereich bestimmt seinen Speicherverbrauch (vergl. Anhang A – primitive Datentypen).

Byte (.b)

Dieser Datentyp verarbeitet kleine Ganzzahlen (Integerwerte) im Wertebereich von -128 bis +127 (-128 … 0 … +128) und verbraucht 1 Byte (8 Bits) Speicher. Er eignet sich z.B. gut als Zählervariable in kurzen Zählschleifen oder zur numerischen Darstellung des ASCII-Zeichensatzes.
Beispiel: DEFTYPE .b kleinerZaehler =  0

Word (.w)

Dieser Datentyp verarbeitet mittelgroße Ganzzahlen im Wertebereich von -32768 bis +32767 (-32768 … 0 … +32767) und verbraucht 2 Bytes (16 Bits) Speicher.
Beispiel: DEFTYPE .w fatNumber =  22000

Long / Long Word (.l)

Dieser Datentyp verarbeitet sehr große Ganzzahlen im Wertebereich von -2³¹  bis +2³¹ und verbraucht 4 Bytes (32 Bits) Speicher.
Beispiel: DEFTYPE .l veryfatNumber =  4711081542

Quick (.q)

Dieser Datentyp verarbeitet kleine Fließkommazahlen im Wertebereich von -32768 bis +32767 unter Verwendung eines festen Dezimalpunkts und verbraucht 4 Bytes (32 Bits) Speicher, erlaubt bis zu 10 Nachkommastellen. Er ist schneller als die Emulation der Float-Typen in Software, aber langsamer als Integer und langsamer als Float-Typen auf einer Hardware-FPU.
Beispiel: DEFTYPE .q smallFloatNumber = 4711.0815

Float (.f)

Dieser Datentyp verarbeitet große, einfachpräzise Fließkommazahlen im Wertebereich von -9*10¹⁸ bis +9*10¹⁸-1 und verbraucht 4 Bytes (32 Bits) Speicher. Er eignet sich besonders zur Verwendung als einfachpräzise Fließkommazahl, wie sie von den Standard-Fließkommabibliotheken des Amiga unterstützt wird und arbeitet mit +/-23bits^{+/-7 bits} (10 Nachkommastellen)Dieser Datentyp ist sehr langsam in Software zu emulieren, aber sehr schnell, wenn Hardware-FPU verwendet wird. Er arbeitet langsamer als Ganzzahlen.
Beispiel: DEFTYPE .f largeFloatNumber = 471143.0815

Double Float (.d)

Dieser Datentyp verarbeitet sehr große, doppeltpräzise Fließkommazahlen mit riesigem Wertebereich und verbraucht 8 Bytes (64 Bits) Speicher, 9 Nachkommastellen. Keine Software-Emulation möglich, daher muss eine Hardware-FPU vorhanden sein, um diesen Datentyp nutzen zu können! Nicht unterstützt in Blitz Basic 2.1 und früher. Langsamer als einfachpräzise Float-Typen. Typische Anwendungsfälle wären ein Programm zur Berechnung von Zinsen über lange Zeiträume oder eine ähnliche Banking-Software und alle Anwendungen, die wissenschaftliche Berechnungen mit Bedarf an hoher Rechengenauigkeit durchführen.
Beispiel: DEFTYPE .d hugeFloatNumber = 471143.0815

Hinweis: Der Inhalt einer Variablen des neuen Datentyps Double Float kann nicht korrekt mit Print und NPrint ausgegeben werden! Beide Befehle liefern nur den ganzzahligen Anteil des Wertes einer Variablen dieses Datentyps – die Stellen nach dem Dezimalpunkt werden von beiden Befehlen unterschlagen. Derzeit unterstützt noch keine einzige BlitzLib diesen Datentypen, sodass er hier nur der Vollständigkeit halber aufgeführt ist! Wenn es vermeidbar ist, dann verwende diesen Datentyp nicht.
Benutze stattdessen den Datentyp Float.

String (.s oder $)

Dieser Datentyp verarbeitet Zeichenketten aus 8-Bit-Zeichen im Speicher, die automatisch durch ein Nullzeichen (\0) abgeschlossen werden und verbraucht 4 Bytes (32 Bits).
Beispiel 1: DEFTYPE .s myStringVar_1
myStringVar_1 = „Ich bin eine Zeichenkette!“
Beispiel 2: myStringVar_2.s = „Ich auch! Ich auch!“
Beispiel 3: myStringVar_3$ = „Und ich erst!“

Datentypen deklarieren

Bei der Deklaration von Datentypen unterscheidet man zwischen der Inline-Deklaration, der expliziten Deklaration und der globalen Festlegung eines bestimmten Default-Datentyps:

• Inline: ergebnis.q = 4711.42 (die Variable wird mit dem angegebenen Typen – hier: QUICK – versehen und gleichzeitig mit einem Wert initialisiert)
• Explizit: DEFTYPE .q ergebnis (die Variable – und nur diese – ist vom angegeben Typ. Hier: QUICK)
• Global: DEFTYPE .q (alle nicht inline oder explizit deklarierten Variablen sind vom Typ, der hier angegeben wurde – in diesem Fall QUICK)

Das Listing „typesize.ab3“ demonstriert die Deklaration und Initialisierung der primitiven Datentypen und gibt deren Speicherbedarf in Bytes und Bits aus. Beachte, dass dieses Listing aufgrund der Verwendung des Datentyps DOUBLE FLOAT nur auf Amigas mit FPU compiliert werden kann!

; ---------------------------------
; Listing: typesize.ab3
; Speicherverbrauch von Datentypen
; Version 1.0
;
; HARDWARE-FPU ERFORDERLICH!
; ---------------------------------
OPTIMIZE 3 ; FPU zuschalten
SYNTAX 1   ; strenger Syntax-Check

; -- Variablendeklaration mit DEFTYPE --
DEFTYPE .b byteVar
DEFTYPE .w wordVar
DEFTYPE .l longVar
DEFTYPE .q quickVar
DEFTYPE .f floatVar
DEFTYPE .d doubleVar
DEFTYPE .s stringVar, byteRes, bitRes

; Amiga Version string und das Compilerdatum
!version {"typesize 1.0 (\\__DATE_GER__)"}

; Variablen initialisieren
byteVar   = -128
wordVar   = 32767
longVar   = 4711081542
quickVar  = 4711.0815234567
floatVar  = 471143.0815421112
doubleVar = 47114384.420815471
stringVar = "BlitzBasic macht Freude."

; Werte ausgeben
byteRes = Str$(SizeOf .b)
bitRes  = Str$((SizeOf .b) * 8)
Print "Speicherverbrauch BYTE: " + byteRes + " Byte ("
NPrint bitRes + " Bits)"
Print "Wert: "
NPrint byteVar
NPrint ""

byteRes = Str$(SizeOf .w)
bitRes  = Str$((SizeOf .w) * 8)
Print "Speicherverbrauch WORD: " + byteRes + " Byte ("
NPrint bitRes + " Bits)"
Print "Wert: "
NPrint wordVar
NPrint ""

byteRes = Str$(SizeOf .l)
bitRes  = Str$((SizeOf .l) * 8)
Print "Speicherverbrauch LONG: " + byteRes + " Byte ("
NPrint bitRes + " Bits)"
Print "Wert: "
NPrint longVar
NPrint ""

byteRes = Str$(SizeOf .q)
bitRes  = Str$((SizeOf .q) * 8)
Print "Speicherverbrauch QUICK: " + byteRes + " Byte ("
NPrint bitRes + " Bits)"
Print "Wert: "
NPrint quickVar
NPrint ""

byteRes = Str$(SizeOf .f)
bitRes  = Str$((SizeOf .f) * 8)
Print "Speicherverbrauch FLOAT: " + byteRes + " Byte ("
NPrint bitRes + " Bits)"
Print "Wert: "
NPrint floatVar
NPrint ""

byteRes = Str$(SizeOf .d)
bitRes  = Str$((SizeOf .d) * 8)
Print "Speicherverbrauch DOUBLE FLOAT: " + byteRes + " Byte ("
NPrint bitRes + " Bits)"
Print "Wert: "
NPrint doubleVar  ; ACHTUNG: NPrint und Print drucken nur den ganzzahligen 
                  ; Anteil des Wertes!
NPrint "ACHTUNG: Ungelöstes Ausgabe-Problem!"
NPrint ""

byteRes = Str$(SizeOf .s)
bitRes  = Str$((SizeOf .s) * 8)
Print "Speicherverbrauch STRING: " + byteRes + " Byte ("
NPrint bitRes + " Bits)"
Print "Wert: "
NPrint stringVar
NPrint ""

End

Ausgabe:

Speicherverbrauch BYTE: 1 Byte (8 Bits)
Wert: -128

Speicherverbrauch WORD: 2 Byte (16 Bits)
Wert: 32767

Speicherverbrauch LONG: 4 Byte (32 Bits)
Wert: 416114246

Speicherverbrauch QUICK: 4 Byte (32 Bits)
Wert: 4711.5781

Speicherverbrauch FLOAT: 4 Byte (32 Bits)
Wert: 471143.5625

Speicherverbrauch DOUBLE FLOAT: 8 Byte (64 Bits)
Wert: 47114384
ACHTUNG: Ungelöstes Ausgabe-Problem!

Speicherverbrauch STRING: 4 Byte (32 Bits)
Wert: BlitzBasic macht Freude.

Programmanalyse:

Das Programm benutzt zwei neue Befehle: Str$() und SizeOf. Str$() wandelt einen numerischen Wert in einen String um. Sizeof liefert den Speicherverbrauch eines Datentyps in Bytes zurück.

Wir verwenden Str$, um den (numerischen) Rückgabewert von Sizeof einer String-Variable zuweisen zu können, die dann bei der Ausgabe durch Print und NPrint zusammen mit anderen Zeichenketten zu einer neuen Zeichenkette zusammengesetzt wird (String Concatenation).

Ablauf:

• In Zeile 8 sorgen wir mit OPTIMIZE 3 dafür, dass neben der Optimierung für die MC68020 CPU auch die FPU verwendet wird (siehe Abschnitt „Optimierte Programme erzeugen“ im Artikel „Das erste Programm„). Das ist nötig, da wir u.a. den Datentyp DOUBLE FLOAT verwenden, der nur auf einer physisch vorhandenen FPU und erst ab AmiBlitz3 verwendet werden kann. BlitzBasic v2 und älter kennen diesen Datentypen nicht.
• Zeile 9 schaltet die strenge Syntax-Prüfung ein, bei der alle Variablen vor ihrer ersten Verwendung per DEFTYPE deklariert werden müssen.
• In den Zeilen 12 bis 18 deklarieren wir per expliziter Deklaration die im Programm verwendeten Variablen mit einem Datentyp.
• Zeile 21 legt den Versions-String fest, der bei Abfrage mit dem DOS-Befehl version meinProgramm full in einer Shell Auskunft über die Versionsnummer und das Erstellungsdatum eines Programms gibt.
• In den Zeilen 24 bis 30 weisen wir einigen der zuvor deklarierten Variablen Werte zu (Initialisierung).
• Die Zeilen 33 bis 39 geben Speicherverbrauch und Inhalt der BYTE-Variablen byteVar aus:
• In Zeile 33 wandeln wir die per SizeOf .b abgefragte Speichergröße (Anzahl Bytes) mittels Str$ in eine Zeichenkette um und weisen sie der String-Variablen byteRes zu.
• In Zeile 34 verfahren wir analog, berechnen hier aber die Anzahl Bits durch Multiplikation mit dem Faktor 8 ( 1 Byte = 8 Bits). Das Ergebnis der Berechnung wird der String-Variablen bitRes zugewiesen.
• In Zeile 35 geben wir per Print (ohne Zeilenvorschub) eine Teilmeldung aus. Sie setzt sich aus mehreren Teilstrings zusammen, die wir mit dem Verknüpfungsoperatur „+“ zu einem Gesamtstring für die Ausgabe zusammensetzen.
• In Zeile 36  geben wir mit NPrint (mit Zeilenvorschub) einen weiteren zusammengesetzten String aus, der die Ausgabe der Speichergröße abschließt.
• Zeile 37 druckt per Print eine weitere Meldung ohne Zeilenvorschub, an welche dann in Zeile 38 per NPrint der Wert (Inhalt) der Variablen byteVar angehängt und anschließend ein Zeilenvorschub ausgeführt wird.
• Zeile 39 druckt mittels einem an NPrint übergebenen Leerstring einen weiteren Zeilenvorschub (ohne Text).
• Analog zu den Zeilen 33 bis 39 werden in den Zeilen 41 bis 89 nacheinander die Speichergrößen und Inhalte für die übrigen Datentypen ausgegeben.
• Das Programm endet in Zeile 91 mit der Anweisung End.

Speicherüberlauf 

Wir haben gelernt, dass jeder Datentyp einen bestimmten Wertebereich besitzt, der die Größe der darstellbaren Inhalte einer Variablen bestimmt. Was aber, wenn dieser Wertebereich überschritten wird? Nun, in diesem Fall kommt es zum Speicherüberlauf. Bei numerischen Variablen hat das zur Konsequenz, dass ihr Inhalt nicht mehr mit dem vermuteten Wert übereinstimmt, was wiederum zu unvorhergesehenem Programmverhalten führt.

Wenn ein Wertebereich überschritten wird, so wird (normalerweise) kein Fehler erzeugt. Stattdessen wird der Wert auf das andere Ende des Wertebereichs umgeschlagen. Dies kann dazu führen, dass einige sehr schwer zu findende Fehler in deinen Code eingeschleust werden!

Ein Beispiel: Der Datentyp BYTE kann Ganzzahlen im Bereich zwischen -128 und + 127 darstellen. Wenn eine BYTE-Variable den Wert +127 besitzt und man addiert nochmal 1 dazu, so ist der Inhalt nicht, wie man vermuten könnte, +128, sondern -128. Das entspricht der unteren Grenze des Wertebereichs. Addiert man nun eine weitere 1 hinzu, so ist der Wert -127.

Im negativen Wertebereich verhält sich das genauso: Wenn eine BYTE-Variable den Wert -128 besitzt und man subtrahiert davon 1 weg, so ist der Inhalt nicht, wie man vermuten könnte, –129, sondern +127. Das entspricht der oberen Grenze des Wertebereichs. Subtrahiert man nun eine weitere 1, so ist der Wert +126. Das Listing „overflow.ab3“ verdeutlicht das eben Gesagte:

; ---------------------------------
; Listing: overflow.ab3
; Ueberlauf von Datentypen
; Version 1.0
; ---------------------------------
OPTIMIZE 1 ; MC68020+ Optimierungen
SYNTAX 1   ; strenger Syntax-Check

; -- Variablendeklaration mit DEFTYPE --
DEFTYPE .b byteVar

; Amiga Version string und das Compilerdatum
!version {"overflow 1.0 (\\__DATE_GER__)"}

; Variable initialisieren
byteVar   = 127 ; positive Obergrenze

; Titel ausgeben
NPrint "=============="
NPrint "-- Overflow --"
NPrint "=============="
NPrint ""

; Wert ausgeben (positiver Bereich)
NPrint "positiver Wertebereich:"
Print "byteVar hat den Anfangswert: "
NPrint byteVar
NPrint "Addiere 1..."
byteVar = byteVar + 1
Print "byteVar hat nun den Wert "
NPrint byteVar
NPrint "Addiere weitere 1..."
byteVar = byteVar + 1
Print "byteVar hat nun den Wert "
NPrint byteVar
NPrint ""

; Wert zuruecksetzen auf Untergrenze
byteVar = -128

; Wert ausgeben (negativer Bereich)
NPrint "Negativer Wertebereich:"
Print "byteVar hat den Anfangswert "
NPrint byteVar
NPrint "Subtrahiere 1..."
byteVar = byteVar - 1
Print "byteVar hat nun den Wert "
NPrint byteVar
NPrint "Subtrahiere weitere 1..."
byteVar = byteVar - 1
Print "byteVar hat nun den Wert "
NPrint byteVar
NPrint ""

NPrint "Habe fertig."
End

Ausgabe:

==============
-- Overflow --
==============

positiver Wertebereich:
byteVar hat den Anfangswert: 127
Addiere 1...
byteVar hat nun den Wert -128
Addiere weitere 1...
byteVar hat nun den Wert -127

Negativer Wertebereich:
byteVar hat den Anfangswert -128
Subtrahiere 1...
byteVar hat nun den Wert 127
Subtrahiere weitere 1...
byteVar hat nun den Wert 126

Habe fertig.

Zum Programmablauf gibt es eigentlich nichts zu sagen – alle vorkommenden Anweisungen und Abläufe haben wir bereits besprochen.

Konstanten

Eine Konstante (von lateinisch constans ‚feststehend‘) in einem Computerprogramm ist ein Behälter für einen Wert, der nach der Zuweisung nicht verändert werden kann. Im Gegensatz zu Variablen ist der einmal festgelegte Wert einer Konstanten zur Laufzeit des Programms bindend.

Ein Rautezeichen (#) vor einem Variablennamen bedeutet, dass es sich um eine Konstante handelt (nicht mehr um eine Variable!) Der Wert einer Konstante ist immer eine Ganzzahl. Anders als in anderen Hochsprache, wie z.B. C/C++, kann man in BlitzBasic keine Konstanten mit anderen Datentypen definieren.

Konstanten haben die folgenden Eigenschaften:

• Sie sind schneller als Variablen und benötigen keinen Speicherplatz.
• machen Programme besser lesbar als Zahlen
• Können in Assembler verwendet werden
• Können mit bedingten Kompilierauswertungen verwendet werden
• Können nur Integer-Werte enthalten
• Erleichtert das Ändern einer konstanten Menge, die in einem Programm verwendet wird
• Können nur über den Quellcode zur Kompilierzeit, aber NICHT zur Laufzeit geändert werden

Neben der Option, eigene Konstanten zu definieren, bringt BlitzBasic schon viele „eingebaute“ Konstante, wie bspw. die Kreiszahl Pi mit. Der wohl wichtigste Aspekt von Konstanten aus der Sicht eines BASIC-Programmierers ist aber wohl, dass alle „magischen Zahlen“, die im Code auftauchen, durch sinnvolle Worte wie #width ersetzt werden können („sprechende“ Namen!).

Das Listing „constants.ab3“ demonstriert die Verwendung von Konstanten.:

; -------------------------
; File: constants.ab3
; Zeigt die Verwendung von
; Konstanten
; Version: 1.0
; -------------------------
OPTIMIZE 1
SYNTAX 1

; Amiga Version String und das Compilerdatum
!version {"constants 1.0 (\\__DATE_GER__)"}

; Konstanten definieren:
#width  = 5
#height = 5

; Variablen deklarieren:
DEFTYPE .w area

; Flaeche berechnen:
area = Abs(#width * #height)

; Ergebnis ausgeben:
Print "Die Flaeche aus " + Str$(#width)
Print " m mal " + Str$(#height)
NPrint " m betraegt " + Str$(Abs(area)) + " qm"
; Interne Konstante Pi ausgeben:
NPrint "Der Wert der Kreiszahl PI ist " + Str$(Pi)
End

Ausgabe:

Die Flaeche aus 5 m mal 5 m betraegt 25 qm
Der Wert der Kreiszahl PI ist 3.141592

Programmanalyse:

Das Programm verwendet den neuen Befehl Abs(). Er dient zur Umwandlung vorzeichenbehafteter Zahlen in vorzeichenlose Zahlen. Wir verwenden ihn zur Umwandlung des in der Variablen area gespeicherten Wertes, der als Produkt der Multiplikation zweier Konstanten sonst u.U. als negative Zahl ausgegeben werden könnte.

• in den Zeilen 14 und 15 definieren wir die Konstanten #width und #height. Sie werden später zur Berechnung einer Fläche herangezogen.
• in Zeile 18 deklarieren wir die Variable area als Variable vom Typ WORD.
• in Zeile 21 berechnen wir die Summe der Fläche und weisen das Ergebnis der Variablen area zu.
• die Zeilen 24 bis 26 dienen der Ausgabe der berechneten Werte. Dabei benutzen wir in Zeile 26 den zuvor erklärten Befehl Abs() zur Umwandlung des in area gespeicherten Wertes – just to make sure…
• in Zeile 28 geben wir den Wert der internen Konstante Pi aus.
• Das Programm endet mit Zeile 29.

Zusammenfassung:

In diesem Teil des Tutorials haben wir gelernt

• Was Datentypen und Variablen sind, welche Datentypen es gibt und wie man Variablen deklariert und initialisiert.
• das der neue Datentyp DOUBLE FLOAT nur mit AmiBlitz3 verwendet werden kann, eine vorhanden FPU voraussetzt – und das man ihn besser nicht verwenden sollte, was sich aber in einer späteren Version von AmiBlitz3 noch ändern kann.
• was Konstanten sind und wie man sie definiert und verwendet.
• dass Konstanten nur Ganzzahlen aufnehmen können und keinen Speicherplatz belegen.

Ausblick

Im nächsten Teil des Tutorials werden wir uns eingehend mit den Grundrechenarten und eigenen Funktionen unter BlitzBasic beschäftigen.

[Zurück zur Übersicht] | [zurück] | [vowärts]