Wer ist online?
Buchempfehlung
FreeBASIC-Chat
Referenz - DIM
Syntax A:
DIM [SHARED] Variable1 [AS Typ] [= einfacherAusdruck] [, _
Variable2 [AS Typ] [= einfacherAusdruck] [, _
...] ]
Syntax B:
DIM [SHARED] AS Typ Variable1 [= einfacherAusdruck] [, _
Variable2 [= einfacherAusdruck] [, _
...] ]
Syntax C:
DIM [SHARED] Array( [ [Startindex TO] Endindex [, _
[Startindex TO] Endindex] [, ...] ] ] ) [AS Typ] [ _
=> {einfacherAusdruck [, einfacherAusdruck [, _ ... ] ] } ]
Anmerkung zur Syntax: Unterstriche (_) am Zeilenende werden von FreeBASIC so interpretiert, als wäre die Zeile nicht unterbrochen; dies dient nur der besseren Übersichtlichkeit und hat letztenendes keine Auswirkungen auf die Programmausführung.
Typ: Anweisung
Kategorie: Speicherverwaltung
Dimensioniert Variablen und Arrays einer angegebenen Größe und eines angegebenen Typs. Ein 
Array ist eine Gruppe aus mehreren Variablen selben Typs, auf dessen einzelne Elemente über einen Index zugegriffen wird.
- 'Variable' und 'Array' sind die Namen von NEUEN, noch nicht verwendeten Variablen oder Arrays.
- SHARED bewirkt, dass die Variable auch Unterprogrammen zugänglich ist.
- AS Typ gibt an, von welchem Typ die Variable sein soll; wird AS Typ ausgelassen, erstellt DIM eine Variable/ein Array vom Standarddatentyp. Dieser wird durch die letzten DEFxxx-Anweisungen festgelegt. Bei Syntax B sind alle Variablen der Liste vom Typ 'Typ'. Achtung: Auch FUNCTION kann hier als Typ angegeben werden! Siehe dazu DYLIBLOAD. Ab FreeBASIC v0.17 muss der Typ explizit angegeben werden, außer es wird mit der Option -lang deprecated compiliert.
- 'einfacherAusdruck' ist ein Ausdruck, der aus Konstanten, Operatoren, Funktionen und Symbolen bestehen darf, jedoch nicht aus Variablen. Der Wert von 'einfacherAusdruck' wird der dimensionierten Variable zugewiesen. Um die Elemente eines Arrays zu befüllen, werden die einzelnen Werte in {geschweifte Klammern} gesetzt und durch Kommata getrennt. Bei mehrdimensionalen Arrays müssen innerhalb der Klammern noch einmal geschweifte Klammern gesetzt werden. Siehe auch Variablen-Initiatoren. Außerdem ist es möglich, hier 'ANY' anzugeben, um festzulegen, dass die Variable nicht initialisiert werden soll; an der Speicherstelle verbleibt der 'Datenmüll', der im Speicher zurückgeblieben ist.
Einfache Variablen werden folgendermaßen dimensioniert:
DIM i AS INTEGER, s AS SINGLE
Nun stellen Sie sich vor, Sie wollten 100 Zahlen speichern, vielleicht sogar 1000! DIM für 1000 Variablen zu benutzen ist eine riesige Arbeit, daher verwendet man Arrays. So dimensionieren Sie ein Array (oft auch Feld genannt) mit 1000 Elementen (in diesem Beispiel wird es 'height' genannt):
DIM height(1 TO 1000) AS INTEGER
Dadurch werden 1000 Speicherstellen für INTEGER-Zahlen reserviert, wobei der Index des ersten Elements 1 ist und der des letzten Elements 1000. Eine andere Möglichkeit wäre diese:
DIM height(999) AS INTEGER
Hier werden ebenfalls 1000 Speicherstellen für INTEGER-Zahlen reserviert, jedoch reichen die Indizes in dieser Form von 0 bis 999. Wird bei der DIM-Anweisung der Startindex ausgelassen, so wird automatisch angenommen, dass der Startindex 0 ist. Durch OPTION BASE lässt sich dies ändern (nur bis FreeBASIC v0.16). Am besten stellen Sie sich den reservierten Speicherbereich als Liste vor, in die alle Werte untereinander eingetragen werden. Wollen Sie nun eine Tabelle erstellen, sprich eine Liste mit 2 Dimensionen, müssen sie auch in der DIM-Anweisung die Größe der zweiten Dimension angeben:
DIM ZweiDimensional (1 TO 100, 50)
Bis FreeBASIC v0.16 wurden Felder mit bis zu vier Dimensionen unterstützt, seit v0.16 sind sogar achtdimensionale Felder zulässig.
Um nun auf die Einträge im Feld zuzugreifen, verwenden Sie die Syntax:
FeldName(Index [, Index [, ...] ])
Beispiel:
DIM feld (3) AS BYTE
DIM tabelle (2, 4) AS INTEGER
feld(0) = 10
feld(1) = -3
feld(2) = feld(0) + feld(1)
tabelle(0, 0) = 10
PRINT feld(1)
Soll bei der Dimensionierung der Variable sofort ein Wert zugewiesen werden, kann dies über die sogenannten Variablen-Initiatoren geschehen:
DIM a AS INTEGER = 5
DIM AS STRING b = "hello world", c = "FreeBASIC" + CHR(13) + "free 32bit Compiler"
' Nur STATIC-Felder können durch Variablen-Initiatoren befüllt werden.
DIM Array(1 TO 3, 2) => { {1, 2, 3}, _
{4, 5, 6}, _
{7, 8, 9} }
Es können auch Felder unbekannter Größe erzeugt werden, sofern diese Arrays DYNAMIC verwaltet werden. Solche Felder können z.B. an Prozeduren übergeben werden, wo sie redimensioniert und befüllt werden. Dabei durften solche Felder unbekannter Größe bis FreeBASIC v0.16 nur auf Modulebene (d.h. nicht in SUBs und FUNCTIONs) verwendet werden; seit FreeBASIC v0.16 können Felder unbekannter Größe an jedem Programmpunkt erstellt werden.
Beispiel:
DECLARE SUB FileList(Path AS STRING, Array() AS STRING)
DIM AS STRING Files()
FileList ENVIRON("TMP"), Files()
SUB FileList(Path AS STRING, Array() AS STRING)
DIM AS STRING filename
DIM AS INTEGER i
filename = DIR(Path + "\*.*")
IF LEN(filename) THEN
REDIM Array(0) AS STRING
Array(0) = filename
i = 1
ELSE
EXIT SUB
END IF
DO
filename = DIR()
IF LEN(filename) THEN
REDIM PRESERVE Array(i) AS STRING
Array(i) = filename
i += 1
ELSE
EXIT DO
END IF
LOOP
END SUB
? UBOUND(Files)
FOR i = 0 TO UBOUND(Files)
PRINT Files(i)
NEXT
GETKEY
Unterschiede zu QB:
- Wenn Sie Variablen als Indexzahl benutzen, müssen Sie das Feld mit REDIM dimensionieren oder DYNAMIC (Metabefehl) benutzen. Dies wird sich in Zukunft vielleicht ändern.
- FreeBASIC unterstützt Variablen-Initiatoren.
Unterschiede zu früheren FreeBASIC-Versionen:
- seit FreeBASIC v0.16 dürfen Felder unbekannter Größe an jedem Programmpunkt, auch in Prozeduren erstellt werden.
- seit FreeBASIC v0.17 muss der Typ explizit deklariert werden, außer das Programm wird mit der Option -lang deprecated compiliert.
Siehe auch:
REDIM, SHARED, SCOPE, STATIC (Anweisung), COMMON, DYNAMIC (Meta), STATIC (Meta), OPTION, DYNAMIC (Schlüsselwort), STATIC (Schlüsselwort), ERASE, CLEAR, Datentypen, Pointer
| Zusätzliche Informationen und Funktionen | ||||
|---|---|---|---|---|
|
||||
Versionen