Das folgende Kapitel befasst sich mit Datentypen und Variablen. Variablen beziehen sich auf eine bestimmte Zahl, eine Zeichenkette oder ein Datenfeld. Der Name einer Variablen darf maximal 40 Zeichen lang sein und folgende Zeichen enthalten:
A-Z, a-z, 0-9
Wichtig ist, dass der Variablenname immer mit einem Buchstaben beginnen muss! Und nun einige Beispiele:
HausNummer% = 3 'die Variable 'HausNummer' ist vom 'Typ INTEGER und hat den Wert 3 Einwohner% = 160000 'FALSCH, weil 'Einwohner' vom Typ 'INTEGER ist, der maximale Wert 'für INTEGER-Variablen ist aber '32767 Einwohner& = 160000 'so ist es richtig |
Wenn die meisten Variablen in einem Programm vom Typ INTEGER sind, können Sie sich die Kennzeichnung dieser Variablen sparen, indem sie als erste Programmzeile folgenden Befehl schreiben:
DEFINT A-Z
Das heißt, dass alle Variablen die nicht anders gekennzeichnet wurden, als INTEGER-Variablen gelten. Der zweite Teil des Befehls (A-Z) bezeichnet die Variablen, die als INTEGER definiert werden sollen. In diesem Fall sind es diejenigen, deren Namen mit A, B, C, D ... oder Z beginnen.
DEFLNG A, B-D, F, X-Z
Alle Variablen deren Name mit den Buchstaben A, B, C, D, F, X, Y oder Z beginnen, gelten als Variablen des Typs LONG. Hier sind alle möglichen Befehle aufgelistet:
DEFINT INTEGER DEFLNG LONG DEFSNG SINGLE DEFDBL DOUBLE DEFSTR STRING
Wenn QuickBASIC bei der Ausführung eines Programms auf eine Variable stößt, und sie nicht besonders gekennzeichnet wurde, so nimmt QuickBASIC abhängig von der Größe der Zahl an, dass diese Variable vom Typ LONG, SINGLE oder sogar DOUBLE sei. Dementsprechend werden mindestens 4 Byte für die jeweilige Variable reserviert. Wird die Variable aber so definiert, wie sie benötigt wird, kann das Speicherplatz sparen. Im Gegensatz zu kleinen Programmen ist das ist besonders bei großen Programmen wichtig. Ein Programmbeispiel:
REM-------------------------------------------------------------- REM Titel: DEFtyp01.BAS REM Autor: Marty Winkler REM Datum: 23.09.2001 REM-------------------------------------------------------------- 'mehrere Definitionen sind möglich! DEFDBL L-P 'L-P => DOUBLE DEFSTR A, H 'A, H => Zeichenketten (Strings) Adresse = "Bertolt-Brecht-Straße" HausNummer% = 3 '% muss sein, weil alle Variablen 'mit Anfangsbuchstaben A und H als 'STRING definiert wurden HausNummer = "3" 'oder man schreibt es so |
Ein anderer Aspekt ist der, dass Variablen vom Typ INTEGER schneller verarbeitet werden können, als Variablen des Typs SINGLE oder DOUBLE. Das folgende Programm verdeutlicht diese Geschwindigkeitsunterschiede äußerst anschaulich:
REM--------------------------------------------------------------
REM Titel: DEFtyp02.BAS
REM Autor: Marty Winkler
REM Datum: 16.12.2001
REM--------------------------------------------------------------
DEFINT A-Z
Anfang! = TIMER
FOR Zaehler# = 0 TO 1000000# STEP 1
TYPint% = 0
NEXT
Ende! = TIMER
PRINT "INTEGER Benötigte Zeit: "; Ende! - Anfang!
Anfang! = TIMER
FOR Zaehler# = 0 TO 1000000# STEP 1
TYPsingle! = 0
NEXT
Ende! = TIMER
PRINT "SINGLE Benötigte Zeit: "; Ende! - Anfang!
Anfang! = TIMER
FOR Zaehler# = 0 TO 1000000# STEP 1
TYPdouble# = 0
NEXT
Ende! = TIMER
PRINT "DOUBLE Benötigte Zeit: "; Ende! - Anfang!
|
In diesem Fall wird der Variablen TYPint der Typ INTEGER (durch %), TYPsingle der Typ SINGLE (durch !) und der Variablen TYPdouble der Typ DOUBLE zugewiesen. Nehmen wir den ersten Teil des Programms doch einmal auseinander:
| DEFINT A-Z | Alle Variablen sind vom Typ INTEGER. |
| Anfang! = TIMER | Die Variable Anfang ist vom Typ einfache Genauigkeit (SINGLE). Der Befehl TIMER gibt
die Anzahl der Sekunden nach Mitternacht zurück. In der Variable Anfang werden hier
also die Sekunden nach Mitternacht gespeichert. |
| FOR Zaehler = 0 TO 1000000# STEP 1 | Diese Befehlszeile leitet eine sogenannte FOR-TO-NEXT-Schleife ein. Wenn man diese
Zeile ins Deutsche übersetzt, so würde sie etwa folgendermaßen lauten: "Für Zaehler = 0 bis Zaehler = 1000000 tue:". Zaehler wird nach jedem Durchlaufen der Schleife um die angegebene Schrittweite erhöht, in diesem Fall 1. Diese Schrittweite wird durch STEP angegeben. STEP kann auch weggelassen werden, dann beträgt die Schrittweite automatisch 1. |
| TYPint% = 0 | In dieser Programmzeile wird festgelegt, dass die Variable TYPint vom Datentyp INTEGER
zu sein hat. Weiterhin wird der Variablen der Wert 0 zugewiesen. |
| NEXT | Mit diesem Befehl wird die FOR-TO-NEXT-Schleife wieder geschlossen. Das heißt, dass alle Befehle, die zwischen FOR und NEXT stehen so oft wiederholt werden, bis Zaehler den Wert 1.000.000 enthält. Trifft der QuickBASIC-Interpreter also auf NEXT, so erhöht er die Variable Zaehler um die Schrittweite (hier 1). Stellt er danach aber fest, dass Zaehler größer ist als 1.000.000, so bearbeitet er den nächsten Befehl. In diesem Fall ist das die folgende Zeile |
| Ende! = TIMER | Ist die Ausführung der Schleife beendet, so wird die aktuelle Anzahl der Sekunden seit Mitternacht
in Ende! gespeichert. |
| PRINT "INTEGER Benötigte Zeit: "; Ende! - Anfang! | Der Befehl PRINT wird im nächsten Kapitel ausführlich behandelt, deswegen erwähne
ich jetzt nur, dass mit ihm der String der in den Anführungszeichen steht auf dem Bildschirm
ausgedruckt wird. Steht dieser Text dann auf dem Monitor, so berechnet QuickBASIC das Ergebnis
folgender Rechenaufgabe: Ende! - Anfang! Danach wird auch das auf dem Bildschirm ausgedruckt, und zwar in die gleiche Zeile wie der Text. Das Ergebnis sind hier die Anzahl der Sekunden, die das Programm benötigt hat, um die Schleife 1.000.000 mal zu durchlaufen. |
Wenn sie einen sehr schnellen Rechner haben, die errechneten Werte sich also kaum unterscheiden, so sollten sie die Anzahl der Schleifendurchläufe (1.000.000) erhöhen. Beachten Sie dabei aber, dass die Zahl im gültigen Bereich liegt (siehe Kapitel 3.1 Datentypen). Führt man dieses Programm schließlich aus, so sieht man deutlich, dass die Schleife, in der mit einer INTEGER-Variablen gearbeitet wird, schneller verarbeitet werden kann, als die mit SINGLE- oder DOUBLE-Variablen. Als ich dieses Programm auf meinem Rechner (Windows 98, 133 MHz) ausführte, bekam ich folgende Werte:
INTEGER Benötigte Zeit: 5 SINGLE Benötigte Zeit: 8,558594 DOUBLE Benötigte Zeit: 8,902344
Geben Sie einmal folgendes Programm ein und führen Sie es aus:
REM-------------------------------------------------------------- REM Titel: SCHNITT1.BAS REM Autor: Marty Winkler REM Datum: 23.09.2001 REM-------------------------------------------------------------- DEFINT A-Z Zensur1 = 3 ' 1. Zensur Zensur2 = 2 ' 2. Zensur Zensur3 = 2 ' 3. Zensur Anzahl = 3 ' Anzahl der Zensuren Durchschnitt = (Zensur1 + Zensur2 + Zensur3) / Anzahl PRINT Durchschnitt |
In diesem Programm werden zuerst alle Variablen als INTEGER deklariert. Danach werden vier Variablen Werte zugewiesen. Als nächstes wird der Durchschnitt errechnet, indem alle Zensuren addiert werden und dann durch die Anzahl der Noten dividiert werden. Das Ergebnis wird in der Variable Durchschnitt abgespeichert. Mit dem Befehl PRINT wird der Inhalt der von Durchschnitt auf den Bildschirm gedruckt. Aber da steht seltsamerweise eine 2, doch (3+ 2 + 2) durch 3 ergibt ungefähr 2.333. Wie kommt also solch ein Ergebnis zustande? Zu Beginn des Programms haben wir festgelegt, das alle Variablen ganze Zahlen (INTEGER) zu sein haben. Was heißen soll, dass auch Durchschnitt eine Ganzzahl ist. Dass heißt, dass das Ergebnis, bevor es in der Variable Durchschnitt gespeichert werden kann zu einer ganzen Zahl gerundet werden muss. In diesem Fall wurde abgerundet (2.33... zu 2). Versuchen Sie es jetzt mit diesem Programm und schauen Sie, was dieses Mal angezeigt wird:
REM-------------------------------------------------------------- REM Titel: SCHNITT2.BAS REM Autor: Marty Winkler REM Datum: 22.09.2001 REM-------------------------------------------------------------- DEFINT A-Z CLS 'CLearScreen = Bildschirm löschen '(näheres im Kapitel 4) Zensur1 = 3 '1. Zensur Zensur2 = 2 '2. Zensur Zensur3 = 2 '3. Zensur Anzahl = 3 'Anzahl der Zensuren Durchschnitt1 = (Zensur1 + Zensur2 + Zensur3) / Anzahl PRINT Durchschnitt1 Durchschnitt2& = (Zensur1 + Zensur2 + Zensur3) / Anzahl PRINT Durchschnitt2& Durchschnitt3! = (Zensur1 + Zensur2 + Zensur3) / Anzahl PRINT Durchschnitt3! Durchschnitt4# = (Zensur1 + Zensur2 + Zensur3) / Anzahl PRINT Durchschnitt4# |
2 (=> INTEGER) 2 (=> LONG) 2.333333 (=> SINGLE) 2.333333333333333 (=> DOUBLE)