2.2 Variablen und Typen

2.2.1 Was sind Variablen?

2.2.2 Numerische Datentypen und numerische Ausdrücke

2.2.3 Stringtypen und Stringausdrücke

2.2.4 Weitere Datentypen

2.2.4.1 Der Datentyp FILE

2.2.4.2 Der Datentyp HANDLE

2.2.4.3 OBJECT Variablen

2.2.4.4 R-BASIC Strukturtypen

2.2.5 Felder

2.2.6 Globale und Lokale Variablen

2.2.7 Interne Verwaltung der Variablen, HUGE Variablen

2.2.8 Strukturen

2.2.8.1 Grundlagen

2.2.8.2 Verschachtelung von Strukturen

2.2.8.3 Strukturen und Felder

2.2.8.4 Strukturen und Unterprogramme

2.2.8.5 Formale Syntax

2.2.8.6 Namenskonventionen

2.2.8.7 Ein Anwendungsbeispiel

2.2.8.8 AnyStruct

2.2.9 Die Funktion SizeOf

2.2.10 Die CONST Anweisung

^

2.2.1 Was sind Variablen?

Wenn Sie eine Zahl oder eine Text abspeichern und anschließend wieder darauf zugreifen wollen, benötigen Sie mindestens zwei Dinge: genug Speicherplatz um die Daten abzulegen und einen Namen, unter dem Sie wieder auf die Daten zugreifen können. Um den Speicherplatz kümmert sich R-BASIC automatisch, nur den Namen müssen Sie selbst vergeben. Unter diesem Namen können Sie später auch eine andere Zahl oder einen anderen Text in diesem Speicherplatz ablegen. Der Inhalt des Speicherplatzes ist also veränderlich, d.h. variabel. Man sagt daher, dass man es mit einer Variablen zu tun hat. Im Sprachgebrauch wird der Begriff "Variable" gleichbedeutend mit dem Variablennamen verwendet. Statt "Die Variable mit dem Namen X" sagt man "Die Variable X". Gemeint ist in beiden Fällen jedoch, dass sich hinter dem Namen X ein Speicherbereich verbirgt, der einen Wert, z.B. eine Zahl oder einen Text, enthält. Variablen, die eine Zahl enthalten, bezeichnet man als "numerische" Variablen. Variablen, die einen Text enthalten, bezeichnet man als "String" Variablen. Der englische Begriff "String" steht für Faden, Schnur bzw. Kette, in unserem Fall für eine Abfolge von Zeichen (= Buchstaben), eine "Zeichenkette".

Um eine Variable zu vereinbaren verwenden wir das Schlüsselwort DIM. Wir müssen außer dem Namen der Variablen auch angeben, welche Art von Daten sie enthalten soll, d.h. wir müssen ihren Typ (auch Datentyp genannt) angeben. Dazu dient das Schlüsselwort AS. Der Typ der Variablen beschreibt außer der Art der Daten auch den benötigten Speicherplatz, die "Größe" der Variablen. Das ist nicht zu verwechseln mit dem Wert der Variablen. Der "Wert" gibt den Inhalt der Variablen an (z.B. "Hallo"), die Größe den bereitgestellten Speicherplatz, z.B. 10 Byte.

Ein einfaches Beispiel: 

DIM X AS REAL
  x = 12      ' Weise der Variablen X den Wert 12 zu
  Print x     ' 12 erscheint
  x = -7.9    ' Weise der Variablen X den Wert -7.9 zu
  Print x     ' -7.9 erscheint

DIM

Mit dem Schlüsselwort DIM werden Variablen vereinbart. DIM ist sehr mächtig und kann in verschiedenen Varianten verwendet werden, die im Folgenden erklärt werden:

Beispiel 1: Einfache Variablendefinition, automatische Typerkennung 

DIM A, B
a = 5
b = 3.7
Print A*B
Es wurden zwei numerische Variablen vom Datentyp "Real" vereinbart. Der Variablen A wird der Wert 5, der Variablen B der Wert 3,7 zugewiesen. Beachten Sie, dass als Dezimaltrennzeichen immer ein Punkt zu schreiben ist. Außerdem sehen Sie, dass die Groß/Kleinschreibung der Variablennamen egal ist. Anschließend wird das Produkt (in unserem Fall 18.5) ausgegeben.

Beispiel 2: Einfache Variablendefinition, automatische Typerkennung 

DIM A$, B$
A$ = "Hallo "
B$ = "Welt"
Print A$; B$
Hier wurden zwei Stringvariablen vereinbart. R-BASIC erkennt an dem nachgestellten Dollarzeichen ($), dass es sich um eine Zeichenkettenvariable (Stringvariable) handeln soll. Das Dollarzeichen ist Teil des Namens der Variablen und darf nicht weggelassen werden. R-BASIC unterscheidet die Variablen A$ (sprich: "A-String") von der Variablen A.

Der Variablen A$ wird der Wert "Hallo ", der Variablen B$ der Wert "Welt" zugeordnet. Die Print-Anweisung gibt den Text "Hallo Welt" aus.

Beispiel 3: Einfache Variablendefinition, automatische Typerkennung 

DIM Auto, Bus$
Diese Anweisung vereinbart die Realvariable Auto und die Stringvariable Bus$.

Wie für alle Bezeichner in R-BASIC gilt auch für Variablen: Sie müssen mit einem Buchstaben beginnen, dürfen Buchstaben, Ziffern und die Sonderzeichen '$' (Dollar) und '_' (Unterstrich) enthalten und können bis zu 32 Zeichen lang sein. Groß- und Kleinschreibung wird nicht unterschieden.

DIM .... AS

Das Schlüsselwort AS legt den Typ der Variablen fest.

Beispiel 4: Numerische Variablen (siehe auch Kapitel 2.2.2) 

DIM A, B AS WORD
DIM Hilf AS Longint
DIM ups AS REAL
Beispiel 5: Stringvariablen (siehe auch Kapitel 2.2.3) 
DIM U$, V$ AS String
DIM Name$ AS String(20)
Es ist in BASIC üblich, alle String Variablen durch ein Dollarzeichen am Ende zu kennzeichnen. Erzwungen wird dies in R-BASIC jedoch nicht.

Beispiel 6: Feldvariablen 

DIM  X(10) AS REAL
Ein Feld fasst Variablen gleichen Typs zusammen. Sie werden über den Feldindex angesprochen. Das Beispiel vereinbart 11 REAL variablen, X(0) (Sprich X-von-Null) bis X-von-10). Felder werden im Abschnitt 2.2.5 ausführlich besprochen.

Hier ist die komplette Liste der Syntaxvarianten von DIM:

Syntax: DIM <VariablenListe>
    Es werden ausschließlich REAL und STRING Variablen vereinbart. Endet der Variablenname auf '$' (Dollar) wird eine Stringvariable vereinbart, ansonsten eine REAL Variable.

    Beispiel: DIM A, B(12), C$, D$(10,10)

Syntax: DIM <VariablenListe> AS <VariablenTyp>
    Es werden Variablen vom angegebenen Typ vereinbart.

    Beispiel: DIM X, Y, Z, P(12), Q(4,4) AS Integer

Syntax: DIM <VariablenListe> AS HUGE <VariablenTyp>
alternativ: HUGE <VariablenListe> AS <VariablenTyp>
    Das Schlüsselwort HUGE (=riesig) ist nur im Zusammenhang mit Feldern zulässig. Es zeigt an, dass die Felder sehr groß sind und daher nicht vollständig im Speicher gehalten werden können.

    Beispiel: DIM F(999, 999) AS HUGE REAL

    Es wird ein Feld mit 1000 x 1000 = 1 000 000 Elementen vereinbart. Jedes Element erfordert 10 Byte, das Feld insgesamt 10 Megabyte.

Dabei bedeuten:

<VariablenListe>
Namen der zu vereinbarenden Variablen. Einfache Variablen und Feldvariablen sind erlaubt.

<VariablenTyp>
Typ der vereinbarten Variablen. Es sind alle R-BASIC bekannten Datentypen erlaubt: Die Standarddatentypen, R-BASIC Strukturtypen und mit dem Schlüsselwort STRUCT selbst definierte Datentypen.


^

2.2.2 Numerische Datentypen und numerische Ausdrücke

Die Verarbeitung von Zahlen und mathematischen Funktionen gehört zu den Kernaufgaben einer Programmiersprache. Numerische Variablen speichern Zahlen. In R-BASIC stehen die folgenden Typen zur Verfügung:

Realvariablen

Realvariablen (real = reelle Zahlen) speichern Zahlen im Bereich von ± 3.9999*104931 mit einer Genauigkeit von 19 Stellen. Zahlen mit negativen Exponenten sind bis ± 10-4931 erlaubt.

Byte, Word, Integer, DWord und Longint Variablen

Für Einsteiger in die Programmierung ist der Zahlentyp REAL völlig ausreichend. Fortgeschrittene Programmierer würden jedoch bald die in der Computertechnik üblichen "kleinen" Zahlentypen vermissen. R-BASIC unterstützt daher zusätzlich die in der Tabelle angegebenen Typen. Sie benötigen auch wesentlich weniger Speicherplatz als Realvariablen.

WWFixed Variablen

Berechnungen mit dem Datentyp WWFixed werden merklich schneller ausgeführt als mit den anderen numerischen Datentypen. Die begrenzte Genauigkeit von 4 Nachkommastellen ist für viele Anwendungszwecke, insbesondere bei der Ausgabe von Grafik, völlig ausreichend. Damit R-BASIC mit WWFixed-Werten rechnet sind besondere Regeln einzuhalten. Diese sind im Kapitel 2.3.6 (Schnelle Mathematik mit WWFixed) beschrieben. Sie sollten dieses Kapitel unbedingt lesen, bevor Sie den Datentyp WWFixed verwenden!

Beispiele: 

DIM a, b, c AS REAL
DIM p, q, r AS Word
DIM u, v, w AS Integer

Hinweise:

  • Mit der Ausnahme von WWFixed rechnet R-BASIC grundsätzlich mit REAL-Zahlen. Die anderen numerischen Typen werden daher vor jeder Benutzung in REAL umgerechnet. Es ist in R-BASIC ein Irrtum anzunehmen, dass die Verwendung der Datentypen Word oder Integer die Rechengeschwindigkeit vergrößert.

  • Als Dezimaltrennzeichen muss immer ein Punkt verwendet werden.

  • Die "kleinen" Zahlentypen können grundsätzlich überall dort verwendet werden, wo auch Realvariablen zulässig sind.

  • Bei Zuweisung von Werten außerhalb des Wertebereichs gilt:
      - Vorzeichenbehaftete Typen (INTEGER, LONGINT) werden auf den größtmöglichen bzw. kleinstmöglichen Wert gesetzt.

      - Vorzeichenlose Typen (BYTE, WORD, DWord) sowie WWFixed arbeiten mit einem Übertrag (Modulo-Operation).

Beispiele für Zuweisungen außerhalb des Wertebereichs: 
DIM x, y     ' REAL Variablen, weil kein Typ vorgegeben
DIM b AS Byte
DIM i AS Integer
DIM w AS Word

  b = 12.3   ' Der Wert 12 wird gespeichert
  b = 300    ' Der Wert 44 wird gespeichert (300 = 256 + 44
             ' bzw. 300 MOD 256 = 44
  i = 98766  ' Gespeichert wird 32767
             ' Das ist der größtmögliche Integerwert
  w = 98766  ' Gespeichert wird 33230
             ' weil 98566 = 65536 + 33230
             ' bzw. 98766 MOD 65536 = 33230
Für Zahlen gelten die folgenden Regeln
  • Einfache Zahlen sind z.B. 12 oder 4.89
    Als Dezimaltrenner wird immer der Punkt '.' verwendet, egal was Sie in den PC/GEOS Voreinstellungen festgelegt haben. Dadurch kann man BASIC-Programme auf allen PC/GEOS-Rechnern sofort laufen lassen.

  • Vor jede Zahl darf ein Vorzeichen (+ oder -) gesetzt werden.

  • Für Zahlen mit 10er-Potenzen wird das E (oder e) verwendet.
      -3,78·1012 wird also so geschrieben: -3.78E12

      6,673·10-11 sieht so aus: 6.673E-11

    Entsprechendes gilt auch für die Ausgabe von Zahlen durch R-BASIC.

  • Leerzeichen innerhalb von Zahlen sind unzulässig.

  • Zahlen können auch in binärer Schreibweise (Vorsatz &B, z.B. 5 als &B101) und in hexadezimaler Schreibweise (Vorsatz &H, z.B. 243 als &HF3) dargestellt werden. In diesen Fällen sind 32 Bit oder 8 Hexadezimalstellen zulässig (Zahlenbereich DWord). Zahlen in dieser Schreibweise werden grundsätzlich als positive Zahlen behandelt.

Tabelle der Rechenoperationen

Mathematische Funktionen

  • R-BASIC verfügt über eine Vielzahl von mathematischen Funktionen. Diese können beliebig verknüpft werden, wobei R-BASIC die üblichen Vorrangregeln (Punktrechnung vor Strichrechnung, Klammern gehen vor usw.) beachtet.
Beispiele: 
y = 4*sin(5*x) + 7
y = sqr( 1 + tan(z))
  • Überall dort, wo in den Beispielen Zahlen oder numerische Variablen verwendet wurden, können auch komplexe numerische Ausdrücke stehen.

^

2.2.3 Stringtypen und Stringausdrücke

Zeichenketten wie z.B. "Hallo Welt" werden in BASIC als Strings bezeichnet. Stringvariablen speichern Zeichenketten (Texte) und sind in BASIC üblicherweise durch ein angehängtes $-Zeichen markiert. Das $-Zeichen ist Teil des Namens und darf nicht weggelassen werden. Es gibt zwei Zeichenkettentypen: STRING und STRING(n).

Variablen, die als STRING vereinbart wurden, können bis zu 128 Zeichen aufnehmen. Variablen vom Typ STRING(n) können bis zu n Zeichen lang sein. Dabei gilt: n <= 1024.

Beispiele: 

DIM T$                       ' STRING Variablen, weil der Name auf $ endet
                             ' Max. 128 Zeichen
DIM  R$, S$ AS STRING        ' Max. 128 Zeichen
DIM  P$, Q$ AS STRING(100)   ' Max. 100 Zeichen
DIM  U$, V$ AS STRING(1024)  ' Max. 1024 Zeichen
                             ' 1024 ist die obere Grenze
DIM  A, B AS STRING          ' Auch Stringvariablen, obwohl
                             ' der Name nicht auf $ endet

Für Strings gelten die folgenden Regeln:

  • Stringkonstanten werden immer in Anführungszeichen gesetzt. Umlaute und Sonderzeichen sind erlaubt.
A$ = "Im Haus des Donners wird mir übel."
  • Stringvariablen sollten immer durch ein $ (Dollarzeichen) am Ende gekennzeichnet sein. z.B. A$ (sprich A-String). Verstöße gegen diese Regel verschlechtern die Lesbarkeit des Programms.

  • Strings können durch den Operator + zusammengefügt werden. Klammern sind erlaubt, aber nicht nötig.
A$ = "Im Haus des Donners "
A$ = A$ + "wird mir übel."
  • Ein Anführungszeichen oder andere besondere Zeichen innerhalb einer Zeichenkette werden mit einem "Rückwärtsstrich" (Backslash) '\' eingeleitet.

    Beispiel: Die Anweisung

A$ = "Im \"Haus des Donners\"!"
    speichert den Text: Im "Haus des Donners"! in der Variablen A$
  • Weitere Zeichen, die mit einem Backslash eingeleitet werden:

    \t Tabulator
    \r oder \n Zeilenschaltung
    \\ Backslash

  • Ein Backslash gefolgt von bis zu drei Ziffern (Dezimalzahl) kann verwendet werden, um ASCII-Zeichen in Strings einzufügen, die nicht direkt auf der Tastatur verfügbar sind./li> 
A$ = "a \180 b"
    Speichert den Text a ¥ b in der Variablen A$

    ASCII-Codes unterhalb von 32 (nicht druckbare Codes) sind ebenso zulässig. Die Null beendet eine String, darauffolgende Zeichen werden ignoriert.

  • Mit der Anweisung CONST können Stringkonstanten definiert werden. Die Stringkennung $ am Ende ist dabei optional.
Beispiel: 
CONST NAME$ = "Müller"
CONST FULL_NAME$ = "Paul " + NAME$
Print "Mein Name ist "; NAME$; ", "; FULL_NAME$

^

2.2.4 Weitere Datentypen

In diesem Abschnitt werden Datentypen beschrieben, die für spezielle Zwecke, in denen Zahlen oder Strings nicht geeignet sind, eingesetzt werden. Die Beispiele enthalten daher gelegentlich Befehle, die erst in den zugehörigen thematischen Kapiteln beschrieben werden. Als Einsteiger werden Sie dieses Kapitel sicher nur überfliegen.

Tabelle der hier beschriebenen Standarddatentypen

Variablen der hier beschriebenen Typen können behandelt werden wie alle anderen Variablen in R-BASIC auch. Man kann z.B. Felder anlegen (z.B. DIM Dateien(10) AS FILE), sie als Elemente von Strukturen verwenden, als Parameter an SUB's oder FUNCTION's übergeben oder als Rückgabetyp von FUNCTION's benutzen.

^

2.2.4.1 Der Datentyp FILE

Wenn Sie mit einer Datei arbeiten wollen, benötigen Sie eine Referenz auf diese Datei. Für diesen Zweck gibt es Variablen vom Typ FILE (Dateivariablen). Alle Dateibefehle erwarten eine solche Variable, um zu wissen, welche Datei gemeint ist. Um die Details, z.B. wo die Datei auf der Platte zu finden ist und wie groß sie aktuell ist, kümmert sich dabei das GEOS-System. Eine ausführliche Beschreibung der Arbeit mit Dateien finden Sie im Kapitel 6 des Handbuchs "Spezielle Themen".

Dateivariablen müssen explizit AS FILE deklariert werden: 

DIM fh AS FILE
Beim Öffnen / Anlegen einer Datei wird der Variablen ein Wert zugewiesen. Die Struktur dieses Wertes ist BASIC-intern und besteht aus mehreren Zahlen. 
fh = FileOpen "info.txt"
Zum Arbeiten mit der Datei verwenden Sie die Variable, z.B. 
x = FileRead ( fh )
FileWrite fh, x
Wenn Sie fertig sind, müssen Sie die Datei schließen: 
FileClose  fh
Danach enthält die Variable immer noch einen Wert, er ist jetzt jedoch ungültig. Deswegen sollten Sie, wenn es nicht zu sehr auf Geschwindigkeit ankommt, die Variable mit Hilfe der Funktion NullFile() einen "Null-Wert" zuweisen, sie also löschen. Dieser Schritt ist jedoch nicht zwingend erforderlich. 
fh = NullFile()

NullFile

NullFile( ) ist eine Funktion, die eine "leere" Dateivariable liefert, d.h. sie dient zum Löschen einer Filevariablen. Achtung! NullFile( ) überschreibt die Referenz in der Filevariablen mit Nullen, ohne die Datei zu schließen! Das muss vorher passiert sein.
Syntax: <fVar> = NullFile( )
Die Klammern sind erforderlich, weil NullFile eine Funktion ist.
<fVar>: Variable vom Typ FILE

Hinweise:

Es ist nicht zwingend erforderlich, eine freigegebene Dateivariable auch mit NullFile( ) zu löschen. R-BASIC kann jedoch eine gelöschte Filevariable erkennen und so eventuell einen Systemabsturz verhindern.

FileInfo$

Die Funktion FileInfo$ liefert einen Text, der interne Informationen über eine Dateivariable liefert. Sie können diese Funktion zur Fehlersuche einsetzen.
Syntax: <stringVar> = FileInfo$( <fileExpr> )
<fileExpr>: Variable oder Ausdruck vom Typ FILE
<stringVar>: Stringvariable

^

2.2.4.2 Der Datentyp HANDLE

Ein "Handle" ( = Anfasser) enthält eine Referenz auf eine Datenstruktur, deren Inhalt von R-BASIC verwaltet wird. Wo die Daten abgelegt sind, wie sie intern organisiert sind usw. braucht den R-BASIC Programmierer nicht zu kümmern, er greift immer indirekt über das Handle auf die Daten zu.

Bild: Eine Handlevariable enthält eine Referenz auf eine Datenstruktur

Üblicherweise gibt es einen BASIC-Befehl, der ein Handle anlegt (d.h. die dahinterstehenden Datenstrukturen initialisiert), einen oder mehrere Befehle, die das Handle benutzen (d.h. auf die dahinter stehenden Datenstrukturen zugreifen) und einen Befehl, der das Handle wieder freigibt. Der letzte Schritt ist sehr wichtig und sollte nicht vergessen werden, da hinter einem Handle oft Speicherblöcke stehen - und Speicher ist bekanntlich knapp unter GEOS.

Der Datentyp HANDLE ermöglicht es R-BASIC auf sehr einfache Weise mit extrem komplexen Datenstrukturen umzugehen. Der Programmierer muss sich nicht mit den Interna dieser Datenstrukturen herumschlagen.

Beispielsweise legt der Befehl FileFindFirst$ (suche die erste Datei und liefere ihren Namen) ein Handle an. Dahinter steht ein Speicherblock, in dem eine Liste der im Ordner vorhandenen Dateien und weitere Verwaltungsdaten abgelegt werden. Der direkte Zugriff auf diese Liste wäre für den BASIC Programmierer sehr aufwändig oder gar nicht machbar. Deswegen benutzt FileFindNext$ das Handle um nacheinander die einzelnen Dateinamen aus der Liste auszulesen. FileFindDone sorgt schließlich dafür, dass der von FileFindFirst$ angeforderte Speicher wieder freigegeben wird. 

DIM han AS HANDLE
DIM name$                            ! Stringvariable
...
name$ = FileFindFirst$ ( han, "*" )  ! Handle initialisieren.
                                     ! "*" heißt: alles finden
...
name$ = FileFindNext$ ( han )        ! Handle benutzen
...
FileFindDone ( han )                 !Handle freigeben, d.h. die
                                     ' Datenstrukturen werden
                                     ' freigegeben. Die in han
                                     ' gespeicherten Werte sind
                                     ' jetzt ungültig.

Bild: Das Handle wurde freigegeben, die Referenz ist noch vorhanden, aber ungültig.

Nachdem das Handle freigegeben wurde (im Beispiel mit FileFindDone) kann die Variable sofort für andere Zwecke wieder verwendet werden.

Das Konzept der Handles ist dem des Datentyps FILE analog. Auch hier werden R-BASIC-intern Daten angelegt (FileOpen), verwendet (FileRead bzw. FileWrite) und wieder freigegeben (FileClose).

NullHandle

NullHandle( ) ist eine Funktion, die ein "leeres" Handle liefert, d.h. sie dient zum Löschen einer Handlevariablen. Achtung! NullHandle( ) überschreibt die Referenz in der Handlevariablen mit Nullen, ohne die dahinter stehenden Datenstrukturen zu löschen! Das muss vorher passiert sein.
Syntax: <han> = NullHandle( )
Die Klammern sind erforderlich, weil NullHandle eine Funktion ist.
<han>: Variable vom Typ HANDLE

Hinweise:

  • Es ist nicht zwingend erforderlich ein freigegebenes Handle auch mit NullHandle( ) zu löschen. Die irrtümliche Verwendung eines bereits ungültigen Handles kann aber zu einem Systemabsturz führen. R-BASIC kann jedoch ein mit NullHandle() gelöschtes Handle erkennen und so eventuell einen Systemabsturz verhindern.

  • Nachdem ein Handle freigegeben wurde (d.h. die dahinter stehenden Datenstrukturen freigegeben wurden) kann die Variable sofort für andere Zwecke wiederverwendet werden. Ein vorheriges Löschen mit NullHandle() ist nicht nötig.

HandleInfo$

Die Funktion HandleInfo$ liefert einen Text, der interne Informationen über jede Art von Handle liefert. Sie können diese Funktion zur Fehlersuche einsetzen.
Syntax: <stringVar> = HandleInfo$( <han> )
<han>: Variable oder Ausdruck vom Typ HANDLE
<stringVar>: Stringvariable

^

2.2.4.3 OBJECT Variablen

Eine Variable vom Type "Object" enthält eine Referenz auf ein GEOS-Objekt, z.B. einen Button, eine Liste oder ein anders Objekt des sogenannten "User-Interface". Eine ausführliche Beschreibung der Arbeit mit Objekten finden Sie im Objekt Handbuch.

Objektvariablen müssen explizit AS OBJECT deklariert werden. Danach kann man ihnen eine Wert (ein Objekt) zuweisen und sie wie jedes explizit aufgeführte Objekt verwenden. 

DIM ob AS OBJECT
ob = DemoPrimary ' Ein Objekt aus dem UI-Code Fenster
ob.Caption$ = "Neue Titelzeile"

NullObj

NullObj( ) ist eine Funktion, die ein "leeres" Objekt liefert, d.h. sie dient zum Löschen einer Objektvariable.
Syntax: <oVar> = NullObj( )
Die Klammern sind erforderlich, weil NullObj eine Funktion ist.
<oVar>: Variable vom Typ OBJECT

ObjInfo$

Die Funktion ObjInfo$ liefert einen Text, der interne Informationen über eine Objektvariable liefert. Sie können diese Funktion zur Fehlersuche einsetzen.
Syntax: <stringVar> = ObjInfo$( <objExpr> )
<objExpr>: Variable oder Ausdruck vom Typ OBJECT
<stringVar>: Stringvariable

^

2.2.4.4 R-BASIC Strukturtypen

Die Strukturtypen sind hier der Vollständigkeit halber aufgelistet. Sie werden im Kontext der Kapitel erklärt, in dem sie gebraucht werden. Im R-BASIC Anhang finden Sie eine Zusammenfassung der Elemente dieser Strukturen und ihrer Bedeutung.



^

2.2.5 Felder

Felder (auch Arrays genannt) sind Zusammenfassungen von Variablen gleichen Typs, die über einen Index abgesprochen werden.

Anfänger haben erfahrungsgemäß Schwierigkeiten, sich diesem Thema zu nähern, aber Felder sind ein sehr leistungsfähiges Konzept, dass in keiner Programmiersprache fehlen darf.

Häufig gibt es nämlich das Problem, dass eine Liste von Werten, z.B. Namen und die dazugehörigen Telefonnummern verarbeitet werden sollen. Natürlich könnte man folgendermaßen vorgehen: 

DIM NA1$, NA2$, NA3$, NA4$' usw.
DIM TEL1, TEL2, TEL3, Tel4' usw.

NA1$ = "Müller" : TEL1 = 1234567' usw.

PRINT NA1$, TEL1
PRINT NA2$, TEL2
PRINT NA3$, TEL3
Das ist nicht nur sehr aufwändig, sondern auch sehr fehleranfällig und unflexibel. Die Lösung für das Problem heißt Felder.

Ein Feld fasst Variablen gleichen Typs (und i.A. gleicher Bedeutung) so zusammen, dass die einzelnen Variablen des Feldes über eine Nummer (den Index) angesprochen werden. Dieser Index geht immer von Null bis zu einem vereinbarten Maximalwert. Die Anweisung 

DIM NA$(10), TEL(10)
vereinbart 11 Stringvariablen und 11 Realvariablen:
    NA$(0), NA$(1), .. usw. bis NA$(10) für die Namen
    TEL(0) bis TEL(10) für die Telefonnummern.
Damit haben wir auf einen Schlag Platz für 11 Personen in der Liste, die außerdem über ihren Index (Nummer) eindeutig identifiziert werden können.

Diese Feldvariablen können genau wie ganz normale Variablen verwendet werden: 

NA$(1) = "Müller"
TEL(1) = 1234567  ' usw.
Feldvariablen sind wie geschaffen für die Zusammenarbeit mit FOR-Schleifen. Die Ausgabe der Namensliste gestaltet sich extrem einfach: 
FOR N = 0 TO 10
  PRINT NA$(N), TEL(N)
NEXT N
Eine Berechnung des Feldindex ist zulässig und wird oft benutzt. Man kann hierfür auch sehr komplexe Formeln verwenden, wenn man will. Sollte das Ergebnis der Indexberechnungen einmal nicht ganzzahlig sein, so schneidet R-BASIC den Wert ab.

Achtung: Wird eine Formel zur Berechnung eines Feldindexes verwendet, kann es passieren, dass das Ergebnis dieser Formel außerhalb des zulässigen Bereichs für den Index liegt. In diesem Fall kommt es zu einem Laufzeitfehler und die Programmabarbeitung wird beendet.

Beispiele: 

DIM A(10) AS WORD  ' A(0) bis A(10)
DIM C$(10,2)       ' C$(0,0) bis  C$(10, 2)
DIM Z(4,2,2,1)     ' 4 Dimensionen - sehr exotisch
  • Für Felder sind alle in R-BASIC vorhandenen Typen zulässig:

    • numerische Typen (Real, Byte, Word, Integer, DWord und Longint)

    • Zeichenketten-Typen String und String(n)

    • Handle, Object und File

    • BASIC interne Strukturtypen

    • selbst definierte Strukturen

  • Der zulässige Index beginnt immer mit Null und endet bei dem in der Vereinbarung angegebenen Wert. Im Beispiel oben: A hat 11 Elemente: A(0) bis A(10) (sprich: A-von-Null bis A-von-10).

  • Die Größe einer Felddimension ist auf 32767 (positive Integerwerte) beschränkt. Folgende Vereinbarung führt zu einem Compilerfehler:
DIM F(35000)  ' DAS GEHT NICHT
  • Felder können bis zu 16 Dimensionen (Indizes) haben. Im Beispiel oben hat C$ zwei und Z hat 4 Dimensionen.

  • Nichtganzzahlige Indizes werden von R-BASIC gerundet

  • Liegt ein Feldindex außerhalb des vereinbarten Bereichs (i.A. durch Berechnung) kommt es zu einem Laufzeitfehler und das Programm wird beendet.

  • Bei der Vereinbarung von Feldern können für die Indizes Konstanten verwendet werden. Erlaubt sind außerdem die Grundrechenarten, Klammern sowie die folgenden Operatoren und Funktionen:
      • die Operationen ^ (Exponent) und MOD (Modulo-Division),
      logische Operatoren (OR, AND, NOT, XOR)
      die Funktionen INT(), ASC() und SizeOf(). 
CONST NUM_WORKERS 20
CONST NUM_PEOPLE NUM_WORKERS + 5

DIM A(NUM_WORKERS), B(NUM_PEOPLE) AS WORD
DIM C(2*NUM_WORKERS - 7)
DIM W( Int(NUM_WORKERS/3) )
DIM Z( 4*sizeof(GeodeToken) + 3 )

Felder mit mehreren Dimensionen:

Obwohl Felder mit einem Index (einer Dimension) oft ausreichen, kann man auch Felder mit mehreren Dimensionen vereinbaren. Zweidimensionale Felder kommen noch recht häufig vor. Die beiden Indizes werden dann häufig als x- und y-Koordinate bezeichnet.

Beispiel 1:

Ein Sudoku-Programm könnte zur Verwaltung der 9 x 9 Felder des Sudokubrettes ein zweidimensionales REAL-Feld verwenden: 

DIM BRETT ( 9, 9) AS REAL

Die linke untere Ecke könnte dem Element BRETT(1,1), rechts unten BRETT(9, 1) und rechts oben BRETT(9, 9) entsprechen. Die Elemente mit dem Index Null sind natürlich auch vorhanden, aber in diesem konkreten Beispiel unbenutzt oder für Spezialaufgaben verwendbar.

Der folgende Code prüft, ob in der ganz rechten Spalte die 7 schon vergeben ist: 

FOR N = 1 TO 9
 IF brett(9, N) = 7 THEN PRINT "7 ist vergeben"
NEXT N
Felder mit mehr als einer Dimension erfordern sehr schnell sehr viel Platz. Das Feld BRETT im obigen Beispiel vereinbart bereits 100 Realvariablen (10 in jeder Dimension). Das kostet schon 1000 Byte Speicherplatz. Als WORD-Feld wären es nur 200 Byte - der Preis dafür ist eine geringfügig erhöhte Zugriffszeit, da die WORD-Werte von R-BASIC vor ihrer Benutzung jedes Mal in eine Realzahl konvertiert werden.

Beispiel 2:

Die Punkte einer Bitmap kann man ebenso als Feld mit zwei Dimensionen (x- und y-Koordinate) auffassen. 

DIMBild(800, 600)ASHUGE DWORD
Da das Feld sehr groß ist (801x601x4 Byte = 1,9 MB) haben wir es als HUGE vereinbart (siehe Abschnitt 2.2.7).

R-BASIC unterstützt bis zu 16 Dimensionen und der HUGE Speicher für Felder kann bis 2 GB groß werden - damit sollten selbst die ausgefallensten Wünsche erfüllbar sein.

^

2.2.6 Globale und Lokale Variablen

Neben dem Datentyp einer Variablen ist es ebenso bedeutsam, welcher Programmteil auf eine Variable zugreifen kann. R-BASIC kennt grundsätzlich zwei Gültigkeitsbereiche von Variablen: globale und lokale Variablen.

Globale Variablen werden außerhalb von Unterprogrammen (SUB's, FUCNTION's und ActionHandlern) vereinbart. Die Vereinbarung (mit DIM) erfolgt üblicherweise am Anfang des Programms. Bei größeren Projekten sollten Sie alle globalen Variablen im "Dim & DATA" Fenster vereinbaren. Auf globale Variablen kann von jedem Programmteil aus zugegriffen werden. Für globale Variablen stehen in R-BASIC drei Speicherbereiche bereit: der eigentliche "globalen Variablenspeicher" (bis zu 12 kByte), der "globalen Stringspeicher" (bis zu bis zu einigen hundert kByte) und der "HUGE Speicher" (bis zu 2 GigaByte). Details dazu finden Sie im nächsten Kapitel.

Sie sollten globale Variablen nur dann einsetzten, wenn es wirklich nötig ist. Besonders Anfänger verwenden gern ausschließlich globale Variablen. Die Verwendung einer globalen Variablen in verschiedenen Unterprogrammen zu verschiedenen Zwecken kann jedoch schnell zu "unerklärlichen" Wechselwirkungen und Fehlen führen.

Lokale Variablen werden innerhalb von Unterprogrammen definiert. Sie sind deswegen nur diesem Unterprogramm bekannt. Dabei gelten die im Folgenden genannten Spielregeln.

  • R-BASIC legt (wie jede andere Programmiersprache auch) den Speicherplatz für diese Variablen erst beim Aufruf des Unterprogramms an und gibt ihn nach Ausführung des Unterprogramms wieder frei.

  • Parameter, die an Unterprogramme übergeben werden, werden intern genau wie lokale Variablen behandelt. R-BASIC kopiert beim Aufruf eines Unterprogramms die Übergabeparameter in den lokalen Variablenbereich des Unterprogramms. Nach Beendigung des Unterprogramms werden die Werte jedoch nicht zurückkopiert.

  • Die Benennung der lokalen Variablen und Parametern kann völlig unabhängig von anderen Programmteilen erfolgen. Namensdopplungen mit globalen Variablen und lokalen Variablen bzw. Parametern anderer Unterprogramme sind daher kein Problem. Bei der Verwendung eines Variablennamens prüft R-BASIC zunächst, ob eine lokale Variable (oder ein Parameter) dieses Namens existiert. Wenn ja, wird diese verwendet. Erst dann wird geprüft, ob eine globale Variable dieses Namens existiert und diese ggf. verwendet. Auf lokale Variablen anderer Unterprogramme kann grundsätzlich nicht zugegriffen werden.
Für lokale Variablen stehen für jedes Unterprogramm bis zu 8 Kilobyte zur Verfügung. Dort werden alle lokalen Variablen, auch die Stringvariablen, abgelegt.

Im folgenden Beispiel gibt es drei globale Variablen (A, B, und X). Die Sub namens DemoSub hat zwei lokale Variablen: Den Parameter X und die Integer-Variable A. Deswegen kann sie auf die globalen Variablen A und X nicht zugreifen. Die Zeile "A = 2 * X - 3" belegt die lokale Variable A mit dem doppelten des Wertes des Parameters X, abzüglich 3. Die Zeile "B = SQR(A)" belegt die globale Variable B mit der Quadratwurzel aus der lokalen Variablen A.

Nach dem Aufruf der Sub mit "DemoSub 12" enthält die globale Variable B den Wert 4,5826 (= Sqr(2*12-3) ). Die globalen Variablen A und X sind nicht verändert. 

DIM A, B, X  ' Globale Variablen vom Typ REAL

SUB DemoSub (X AS word)
DIM A as Integer
  A = 2 * X - 3
  B = SQR(A)
END SUB

' Aufruf:
DemoSub 12
Die Belegung einer globalen Variablen in einer SUB ist prinzipiell ein schlechter Stil und sollte vermieden werden (was leider nicht immer geht). Sauberer wäre im obigen Beispiel die Verwendung einer Funktion, die einen Wert zurückliefert: 
DIM A, B, X  ' Globale Variablen vom Typ REAL

FUNCTION DemoFunc (X AS word) AS REAL
DIM A as Integer
   = 2 * X - 3
  RETRUN SQR(A)
END FUNCTION
' Aufruf:
B = DemoFunc ( 12 )

^

2.2.7 Interne Verwaltung der Variablen, HUGE Variablen

Lokale Variablen werden alle in einem Speicherblock abgelegt, der "lokaler Variablenspeicher" genannt wird. Dadurch ist ein sehr effizienter Zugriff auf die lokalen Variablen möglich. Jedes Unterprogramm hat seinen eigenen lokalen Variablenspeicher. Dieser Speicherblock kann für jedes Unterprogramm bis zu 8 Kilobyte groß sein. Das ist meist mehr als genug, PC/GEOS-SDK-Programmierer haben z.B. deutlich weniger zur Verfügung.

Ein häufiger auftretendes Problem bei lokalen Variablen sind jedoch Variablenfelder vom Typ STRING, da jedes Feldelement 129 Byte benötigt. Die (lokale) Anweisung 

DIM SF$(120) AS STRING
erzeugt ein Feld mit 121 Elementen (Index von Null bis 120) und fordert bereits 121 Elemente a 129 Byte = 15609 Byte an. Es kommt zu einem Compilerfehler. Sie können dann entweder den Datentyp STRING(N) verwenden, z.B. 
DIM SF$(120) AS STRING(64)
womit nur 121*65 = 7865 Byte angefordert werden oder auf globale Stringvariablen (STRING oder HUGE STRING) ausweichen.

Für globale Variablen verwendet R-BASIC drei verschiedene Speicherbereiche. Im normalen "globalen Variablenspeicher" werden alle Variablen und Felder abgelegt, die nicht vom Datentyp STRING oder STRING(N) sind und die nicht mit dem Schlüsselwort HUGE vereinbart wurden. Für den globalen Variablenspeicher stellt R-BASIC bis zu 12 Kilobyte Speicher bereit. Auf Variablen im globalen Variablenspeicher kann sehr effizient zugegriffen werden. Die globale Vereinbarung 

DIM RF(200) AS REAL
erzeugt ein Feld mit 201 Elementen (Index von Null bis 200) und belegt 201*10 = 2010 Byte im globalen Variablenspeicher. Hingegen belegt die globale Vereinbarung 
DIM SF$(200) AS STRING
keinen Speicher im globalen Variablenspeicher. STRING Variablen (und Variablen vom Typ STRING(N) ) werden immer im globalen Stringspeicher angelegt. Dieser Speicher wird von R-BASIC dynamisch und effektiv verwaltet, da der wirklich von einer Stringvariablen benötigte Platz davon abhängt, ob sie einen kurzen oder einen langen Text enthält. Je nach erforderlicher Situation legt R-BASIC Stringvariablen im RAM oder in einer Datei ab. Sie können insgesamt 16383 (&H3FFF) globale Stringvariablen vereinbaren, wobei jedes Feldelement als eigene Variable zu zählen ist. Die Länge der Strings ist dabei unerheblich. Auch ein Stringfeld mit 16000 Elementen ist daher kein Problem: 
DIM SF$(16000) AS String(128)
R-BASIC stellt die erforderlichen 2 Megabyte bereit.

Wollen Sie noch größere Felder verwalten können Sie das Schlüsselwort HUGE (= riesig) verwenden. Der Huge Speicher ist eine von R-BASIC bereitgestellte Datei auf der Festplatte. Alle HUGE Feldelemente haben eine feste Größe und eine feste Position in der Datei (d.h. eine dynamische Stringverwaltung findet nicht statt). Sie können auf die HUGE Variablen mit der ganz normalen BASIC Syntax zugreifen, die Dateiverwaltung von GEOS sorgt dafür, dass der Geschwindigkeitsverlust durch die häufigen Festplattenzugriffe nicht allzu groß ausfällt. Der Huge Speicher kann insgesamt bis zu 2 Gigabyte groß sein. Jedoch darf auch bei HUGE Feldern ein einzelner Feldindex den Wert 32767 nicht überschreiten. Verwenden Sie für größere Datenmengen bitte mehrdimensionale Felder. Das folgende Beispiel vereinbart drei Realfelder und ein Wordfeld der Gesamtgröße von ca. 42 Megabyte. 

DIM ImageRed(1280, 1024) AS HUGE REAL
DIM ImageGreen(1280, 1024) AS HUGE REAL
DIM ImageBlue(1280, 1024) AS HUGE REAL
DIM ImageMask(1280, 1024) AS HUGE WORD

^

2.2.8 Strukturen

Mit Hilfe der STRUCT-Anweisung kann man Variablen unterschiedlichen Typs zusammenfassen. Anfänger haben erfahrungsgemäß Schwierigkeiten, sich diesem Thema zu nähern, aber Strukturen sind ein sehr leistungsfähiges Konzept, dass in keiner Programmiersprache fehlen darf.

^

2.2.8.1 Grundlagen

Häufig besteht das Problem, dass zum Verwalten von Daten sehr viele Informationen für ein einzelnes Objekt gespeichert werden müssen. Beispielsweise benötigt man für eine Kontaktliste neben Namen und Vornamen auch Telefon, Email, Fax, Geburtsdatum und einiges mehr.

Strukturen bieten die Möglichkeit, alle diese Informationen "im Block" zu speichern und zu verwalten. Dazu muss man zunächst einen neuen Struktur-Typ vereinbaren, der alle nötigen Informationen enthält. Die Syntax sieht so aus: 

STRUCT Person       ' Person ist der Name des neuen Strukturtyps
Name$, Vorname$ AS String(30)
Tel$ AS String(15)
persNummer AS Word  ' max 65000 - das reicht
END STRUCT          ' Ende der Definition
Anmerkung 1: Strukturen müssen bei ihrer Vereinbarung mit STRUCT eine feste Größe haben. Daher muss der Datentyp STRING(N) verwendet werden, der Platz für einen String der maximalen Länge N fest reserviert.

Anmerkung 2: Strukturen sind auf eine Größe von 3500 Byte begrenzt. Man sollte daher, besonders bei größeren Strukturen, darauf achten, welche Datentypen man einsetzt. REAL kostet z.B. 10 Byte, WORD aber nur 2. String(n) reserviert N+1 Byte (Max. N Zeichen plus 1 Byte Ende-Kennung). Eine einfache Variable der oben definierten Struktur "Person" benötigt z.B. 80 Byte.

Will man den neuen Typ verwenden, vereinbart man einfach mit DIM entsprechende Variablen: 

DIM Chef, Knecht, Magd AS Person
Verwendet werden Strukturvariablen genau wie alle anderen Variablen, allerdings muss man sowohl die Variable (z.B. Chef) als auch das Strukturelement (z.B. Name$), getrennt durch einen einfachen Punkt '.' angeben. 
Chef.Name$ = "Schneider"
Chef.Vorname$ = "Wilhelm"
Chef.Tel$ = "030 456 897 5654"
Chef.persNummer = 1           ' Der Boss ist wichtig
Magd.Name$ = Knecht.Name$     ' Sie haben geheiratet
Man kann aber auch eine komplette Strukturvariable einer anderen zuweisen, vorausgesetzt der Typ stimmt überein. Dadurch werden die Daten kopiert (Zeile 1). Zeile 2 und 3 dienen der Illustration. 
Chef = Knecht          ' Er wurde befördert
Chef.persNummer = 1    ' persNummer wurde auch kopiert:
                       ' neu setzen
Knecht.persNummer = 0  ' Die Stelle ist verfügbar.
Ein weiterer Vorteil: Wenn man später feststellt, dass man eine wichtige Information, z.B. den Geburtsort, hinzufügen will, ist das kein Problem. Man ergänzt einfach die Strukturdefinition: 
STRUCT Person
  Name$, Vorname$ AS String(30)
  Tel$  AS String(15)
  gebOrt$ AS String(20)  ' das ist neu.
  persNummer AS Word
END  STRUCT
Alle bisher geschriebenen Programmteile arbeiten weiter wie gewohnt, man muss nur den Code zum Verwalten des Geburtsortes hinzufügen.

Für die Elemente einer Struktur sind - mit Ausnahme des Typs STRING - alle in R-BASIC vorhandenen Typen zulässig:

    - numerische Typen (Real, Byte, Word, Integer, DWord und Longint)

    - Zeichenketten-Typ: nur String(n). (String ohne (n) ist unzulässig)

    - Object, File und Handle

    - andere Strukturen: R-BASIC intern oder selbst definiert

    - Felder der oben genannten Typen

NullStruct

Die Funktion NullStruct() liefert eine "leere" Sruktur zurück, dient also zum Löschen einer Struktur-Variablen. NullStruct ist auf Strukturen jeden Typs anwendbar, ebenso auf Struktur-Elemente, die selbst Strukturen sind.
Syntax: strukturVariable = NullStruct()
Parameter: Keine. Die Klammern sind aber erforderlich.
Beispiel: 
STRUCT Stru1
  A, B AS REAL
END STRUCT

STRUCT Stru2
  A AS REAL
  S, T AS Stru1
END STRUCT

DIM stVar AS Stru2
  stVar = NullStruct()    ' Löscht die gesamte Struktur
  stVar.s = NullStruct()  ' Löscht nur stVar.s
                          ' stVar.a und stVar.t bleiben erhalten

^

2.2.8.2 Verschachtelung von Strukturen

Es ist zulässig Strukturen zu definieren, die andere Strukturen als Elemente enthalten. Dies bezeichnet man als Verschachtelung von Strukturen.

Die Verschachtelung von Strukturen untereinander ist prinzipiell unbegrenzt. Eine gute Planung der Strukturen ist aber Voraussetzung, sonst werden diese Verschachtelungen schnell unübersichtlich und damit fehleranfällig.

Beispiel 

STRUCT Firmenleitung
  TheBoss AS  Person
  Tippse AS  Person
  Buchhalter As Person
END STRUCT

DIM DieChefsAS Firmenleitung
  DieChefs.TheBoss.Name$ = "Setag"
  DieChefs.TheBoss.Vorname$ = "Llib"
  DieChefs.Tippse.Name$ = "Clausen"
  DieChefs.Tippse.Vorname$ = "Ella"
Die Gesamtgröße einer Struktur ergibt sich als Summe der Größe der einzelnen Strukturelemente. Die Struktur "Firmenleitung" belegt z.B. 303 Byte. Bei Verwendung von Felder innerhalb von Strukturen ist zu beachten, dass der Feldindex immer bei Null beginnt. R-BASIC unterstützt Strukturen bis zu einer Größe von 3500 Byte.

^

2.2.8.3 Strukturen und Felder

Strukturen können beliebig mit Feldern kombiniert werden. Hier sehen Sie an einigen Beispielen, wie das geht. Beachten Sie jeweils die Position der Feldindizes (die in den Klammern)

Felder von Strukturen

STRUCT Point                ' Punkt mit 2 Koordinaten
  px, py AS Word
END STRUCT

DIM pointList(10) AS Point  ' 11 Punkte
  pointList(0).px = 0       ' Erster Punkt, Koordinaten (0,0)
  pointList(0).py = 0
  pointList(1).px = 100     ' Zweiter Punkt, Koordinaten (100,50)
  pointList(1).py = 50

Felder als Strukturelemente

STRUCT  ByteFeld
  anzahl AS Integer
  value(2000) AS Byte  ' 2000 Byte. value heißt "Wert"
END STRUCT

DIM puffer AS ByteFeld
  puffer.value(10) = 27
  puffer.value(11) = 15
  PRINT  puffer.value(10) + 256 * puffer.value(11)
Die Struktur "Person" aus dem Abschnitt 2.2.8.1 wird vorausgesetzt: 
STRUCT  Firma
  Name$ AS String(100)  ' z.B. der Firmenname
  Worker(16) AS Person
END STRUCT            ' Insgesamt 1818 Byte.

DIM Metzgerei AS Firma
  Metzgerei.Name$ = "Metzger Hackbeil"
  Metzgerei.Worker(0).Name$ = "Malocher"
  Metzgerei.Worker(0).Vorname$ = "Max"
  Metzgerei.Worker(1).Name$ = "Schufter"
  Metzgerei.Worker(1).Vorname$ = "Siegfried"

^

2.2.8.4 Strukturen und Unterprogramme

Strukturen können als Parameter und Rückgabewerte von Unterprogrammen (SUB's, FUNCTON's ) verwendet werden. Das folgende Beispiel illustriert das. Die Struktur "Person" aus dem Abschnitt 2.2.8.1 wird vorausgesetzt: 
SUB PrintPerson(p AS Person)
  Print p.Vorname$;" ";p.Name$;" Tel.";p.Tel$
END SUB

FUNCTION NewPerson (n$, v$, geb$ as string) AS Person
DIM P AS Person
  p.Name$ = n$
  p.Vorname$ = v$
  p.GebOrt$ = geb$
  RETURN P
END FUNCTION

DIM Jemandas Person
  Jemand = NewPerson("Panther", "Paulchen", "Farbtopf")
  PrintPerson(Jemand)' Die Klammern sind optional

^

2.2.8.5 Formale Syntax

Aus Kompatibilitätsgründen werden je zwei Syntaxvarianten für Strukturen und Strukturvariablen unterstützt. Funktionell unterscheiden sich die Varianten aber nicht.

Vereinbarung von Strukturen

Standard Syntaxvariante
    STRUCT <StructName>
    <elementListe> AS Type   ' z.B. a, b AS Real
    ...                                       ' weitere Strukturelemente
    END STRUCT
Syntaxvariante mit DIM
    STRUCT <StructName>
    DIM <elementListe> AS Type   ' z.B. DIM a, b AS Real
    ...
    END STRUCT

Vereinbarung von Strukturvariablen

Standard Syntaxvariante
    DIM <varListe> AS StructName

Syntaxvariante mit STRUCT

    DIM <varListe> AS STRUCT StructName
Beispiele Standardsyntax: 
STRUCT BspStruct
  a, b AS real
  c$ AS String(20)
END STRUCT

DIM P1, P2 As BspStruct
Beispiele alternative Syntax: 
STRUCT BspStruct
  DIM a, b AS real
  DIM c$ AS String(20)
END STRUCT

DIM P1, P2 AS STRUCT BspStruct

^

2.2.8.6 Namenskonventionen

Für die Bezeichnung von Strukturen und Strukturelementen gelten genau zwei einfache Regeln:
  1. Der Name des Strukturtyps (z.B. Point s. unten) muss innerhalb des Programms eindeutig sein. Es gelten die gleichen Konventionen wie für globale Variablen oder Unterprogramme.

  2. Der Name von Strukturelementen muss nur innerhalb der Struktur eindeutig sein. Namensdopplungen mit globalen Variablen, Elementen anderer Strukturen, ja sogar mit BASIC Befehlen, sind erlaubt. Sie haben bei Strukturelementen also wesentliche mehr Freiheiten als bei einfachen Variablen.
Am besten verwenden Sie einfache, selbsterklärende Bezeichnungen. Falls R-BASIC ein Problem findet, gibt es einen Compilerfehler, d.h. ein Programm, dass sich compilieren lässt, ist namenstechnisch in Ordnung.

Die folgenden Beispiele zeigen einige Möglichkeiten auf. 
STRUCT Point        ' eine einfache Struktur
  px, py AS Word
END  STRUCT

STRUCT Demo
  a, b AS Real      ' nichts besonderes
  pi  AS Byte       ' kein Konflikt mit 3.1415...
  px, py AS Word    ' kein Konflikt mit der Struktur Point
  color AS Longint  ' selbst BASIC-Befehle sind zulässig
  p AS Point        ' Struktur innerhalb der Struktur
  p2 AS Point       ' Struktur innerhalb der Struktur
END STRUCT

' Variablen-Definitionen
DIM d AS Demo
DIM A AS Demo       ' kein Problem mit A in der Struktur Demo
DIM px AS REAL      ' kein Problem mit px in der Struktur Point

  px = 12           ' Zuweisung zur Realvariablen

 d.pi  = 12
 d.px = 45
 d.p.px = 59        ' d.px wird nicht geändert
 d.p2.px = 79       ' d.p.px und d.px bleiben erhalten
 d.a = pi           ' weist 3.1415... zu.
                    ' d.pi bleibt erhalten (=12, siehe oben)

Das folgende Beispiel zeigt zwar zulässige Vereinbarungen die aber namenstechnisch sehr unübersichtlich gewählt sind: 
STRUCT Point     ' eine einfache Struktur
  px, py AS Word
END STRUCT

STRUCT Komisch
point AS Point   ' selbst dieser Name ist zulässig
komisch AS Real  ' Kein Problem mit dem Namen der
                 ' Struktur, aber sehr unübersichtlich
END STRUCT

DIM py AS Point  ' py ist hier erlaubt, auch wenn es schon
                 ' in Point enthalten ist
                 ' das ist aber nicht mehr übersichtlich
DIM k AS Komisch

py.px = 28       ' Zuweisung zum Strukturelement px der
                 ' Strukturvariablen py
  py.py = 234    ' R-BASIC verwechselt das nicht
  k.komisch = 12
  k.point.px = 17

Beispiel für eine unzulässige Vereinbarung 
STRUCT Line  ' Schlecht. LINE ist ein BASIC-Befehl
  x0, y0, x1, y1 AS Word
END  STRUCT

^

2.2.8.7 Ein Anwendungsbeispiel

Mit Strukturen kann man sehr einfach externe Daten abbilden. Das Beispiel zeigt die Struktur der ersten Bytes einer PCX-Datei, des sogenannten Headers. Der Code am Ende des Beispiels liest den PCX-Header komplett ein und gibt die Abmessungen des Bildes aus. 
STRUCT PCXPalette             ' ein Farb-Paletteneintrag
  rt, gn, bl AS Byte
END STRUCT

STRUCT PCXFileHeader          ' steht am Dateianfang
  id, version AS Byte
  compressed AS Byte
  bitsPerPlane AS Byte
  xMin, yMin AS Word
  xMax, yMax AS Word
  xRes, yRes AS Word
  colorMap(16) AS PCXPalette  ' ein Struktur-Feld
  reserved AS Byte
  colorPlanes AS Byte
  bytesPerLine AS Word
  paletteInformation AS Word
  screenSizeX AS Word
  screenSizeY AS Word
  fill (53) AS Byte           ' ein Byte Feld, 54 Byte
END STRUCT

DIM header AS PCXFileHeader
DIM f AS FILE

  f = FileOpen("FLOWER.PCX")
  header = FileRead ( f, SizeOf(PCXFileHeader))  ' alles
                                                 ' einlesen
  FileClose (f)
  Print "Abmessungen:"; header.xMax; "x"; header.yMax; "Pixel"

^

2.2.8.8 AnyStruct

Dieser Abschnitt richtet sich an fortgeschrittene Programmierer. Eine Übersicht über die verschiedenen Strukturtypen, die in R-BASIC definiert sind, können Sie im Abschnitt 2.2.4.4 finden.

In sehr seltenen Spezialfällen sind Routinen sinnvoll, denen in verschiedenen Situationen Strukturen verschiedener Typen übergeben werden sollen oder die in unterschiedlichen Situationen Strukturen verschiedener Typen zurückgeben sollen. Dafür dient der Typ AnyStruct. Variablen oder Funktionen von diesem Typ sind zuweisungskompatibel zu jedem beliebigen Strukturtyp.

Die Library "VMFiles" macht davon Gebrauch.

Definition: 

STRUCT AnyStruct
  any_struct_dummy_byte_array_ (3499) as BYTE
End struct
Hinweise:
  • Eine Variable oder ein Parameter des Typs AnyStruct belegt 3500 Byte im Variablenspeicher.

  • Es ist im Allgemeinen nicht nötig, auf die Elemente dieser Struktur zuzugreifen.

  • Bei eine Zuweisung oder Parameterübergabe werden stets nur so viele Bytes kopiert, wie der kleinere der beteiligten Strukturtypen fassen kann.

Beispiel 1: Einfache Zuweisungen 
DIM g AS GeodeToken
DIM t AS DateAndTime
DIM a AS AnyStruct

! Erlaubt ist z.B. folgendes
g = a
a = t

Beispiel 2: Übergabe verschiedener Strukturtypen an eine SUB 
DIM g AS GeodeToken
DIM t AS DateAndTime

DECL SUB AnyTest1(a as AnyStruct, x as WORD)

AnyTest1(g, 0)  ' Übergabe GeodeToken
AnyTest1(t, 1)  ' Übergabe DateAndTime

Beispiel 3: Rückgabe verschiedener Strukturtypen 
DIM g AS GeodeToken
DIM t AS DateAndTime

DECL Function AnyTest2(x as WORD) AS AnyStruct

g = AnyTest2(0)  ' Zuweisung an eine GeodeToken Struktur
t = AnyTest2(1)  ' Zuweisung an eine DateAndTime Struktur

Implementationen der Routinen aus den Beispielen 
SUB AnyTest1(a as AnyStruct, x as WORD)
DIM gt as GeodeToken
DIM dat as DateAndTime
  IF x = 0 THEN
    gt = a
    <hier mit gt arbeiten>
  ELSE
    dat = a
    <hier mit dat arbeiten>
  END IF
END SUB

Function AnyTest2(x as WORD) AS AnyStruct
DIM gt as GeodeToken
DIM dat as DateAndTime
  IF x = 0 THEN
    <hier gt belegen>
    return gt
  ELSE
    <hier dat belegen>
    return dat
  END IF
END FUNCTION

^

2.2.9 Die Funktion SizeOf

Die Funktion SizeOf (Größe von) liefert den Speicherbedarf einer Variablen oder eines Datentyps. Diese Funktion ist sehr hilfreich bei der Fehlersuche und im Zusammenhang mit Strukturen. Außerdem können Sie Ihr Programm besser lesbar gestalten. Die Formulierung "10 * SizeOf(WORD)" macht klar, dass der Speicherbedarf von 10 Word-Variablen gemeint ist, während die Zahl 20 alles Mögliche bedeuten kann. Die Verwendung von SizeOf für Strukturen erspart Ihnen das mühsame und fehleranfällige Zusammenzählen der Größen der einzelnen Elemente und liefert automatisch wieder den korrekten Wert, wenn Sie die Definition der Struktur später ändern.
Syntax: <numVar> = SizeOf( type )
type: Beschreibt den Datentyp, dessen Größe ermittelt werden soll.

Wichtig:

    SizeOf() wird schon vom Compiler in eine Zahl übersetzt, d.h. es ist von der Ablaufgeschwindigkeit egal ob Sie schreiben:

    y = 10 oder y = SizeOf (REAL)

Zulässig für type sind:

  • R-BASIC Datentypen (Real, Byte, Word, File usw.)

  • von R-BASIC definierte Strukturdatentypen (GeodeToken, DateAndTime, NumberFormatStruct usw.)

  • mit STRUCT selbst definierte Datentypen

  • Variablen beliebigen Typs:

      • - Einfache Variablen
      - Feldvariablen
      - Strukturvariablen
      - Strukturelemente

Nicht zulässig sind einfache Systemvariablen (z.B. MaxX, tabWidth, FileError usw.) und Strukturelemente von Systemvariablen (z.B. graphic.areaColor).

Beispiel 1: 
DIM y, a, c$
DIM s$ AS STRING(30)

y = SizeOf(REAL)  ' liefert 10
y = SizeOf(A)     ' liefert 10
y = SizeOf(C$)    ' liefert 129
y = SizeOf(S$)    ' liefert 31

Beispiel 2 (komplexes Beispiel): 
' Es sei eine Struktur MyStruct definiert:
STRUCT MyStruct
  a, b(12) AS word
END STRUCT

DIM  msVar AS MyStruct
  y = SizeOf(MyStruct)     ' in diesem Fall: 28
  y = SizeOf(msVar)        ' in diesem Fall: 28
  y = SizeOf(msVar.a)      ' in diesem Fall: 2
  y = SizeOf(msVar.b(0))   ' in diesem Fall: 2

DIM  msFeld(4) AS MyStruct
  y = SizeOf(msFeld(0))    ' in diesem Fall: 28
  y = SizeOf(msFeld(0).a)  ' in diesem Fall: 2

^

2.2.10 Die CONST Anweisung

Mit der Anweisung CONST kann man symbolische Namen für numerische Werte oder Strings festlegen. Diese werden vom Compiler durch ihren Wert ersetzt.
Syntax: CONST name = <wert>
Der Typ der Konstante wird durch den Typ des Wertes bestimmt. Pro Anweisung kann nur eine Konstante definiert werden.

Beispiele: 
CONST anzahl_werte = 12    ' eine Real-Konstante
CONST testwert = -3.786    ' jede Zahl ist zulässig
CONST author$ = "Mein Name"
Vorteile:
    - Das Programm wird übersichtlicher und besser lesbar

    - Die Fehlerwahrscheinlichkeit sinkt drastisch

Ändert man den Konstanten-Wert (eine Stelle im Programm), so wirkt sich die Änderung an alles Stellen aus, an denen die Konstante verwendet wurde.

Im folgenden Beispiel braucht man beim Ändern der Konstanten (anzahl oder startwert) den Code nicht anzupassen: 
CONST anzahl = 31
CONST startwert = 115.7
DIM N, Feld(anzahl)

  FOR N = 0 TO anzahl
  Feld(N) = startwert
  NEXT N

Numerische Konstantendefinitionen können sich auf andere Konstanten beziehen und diese mit Zahlen, den Grundrechenarten und Klammern verknüpfen. Außerdem sind zugelassen: Die Operationen ^ (Exponent) und MOD (Modulo-Division), logische Operatoren (OR, AND, NOT, XOR) und die Funktionen INT(), ASC() und SizeOf(). Für Stringkonstanten ist nur das Pluszeichen erlaubt. 
CONST MAX_X 600
CONST DELTA_X SizeOf(MyStruct) + 10
CONST MAX_Y 2 * MAX_X + DELTA_X
CONST MASK_X INT((MAX_X+7)/8)
CONST K2 (MAX_X AND &hF) OR 3
CONST NAME_SIMPEL "Meier"
CONST NAME_FULL "Hans " + NAME_SIMPEL

Analog darf man auch bei Felddefinitionen vorgehen: 
DIM A(MAX_X), B(MAX_X + DELTA_X / 2) AS WORD

^

Weiter...