SelfQB - ein QBasic-Crashkurs

Inhalt

1. Was ist SelfQB?
2. Was ist QBasic?
3. Wie bekomme ich QBasic auf meinen Computer?
4. Mein erstes Programm
5. Farbcodes
6. Variablen und Datentypen
7. Verzweigungen und Anwendereingaben
8. Schleifen und Abfrage von Einzeltasten-Betätigungen
9. Die QBasic-Onlinehilfe
10. Wartezeiten erzeugen
11. Mathe-Funktionen und FOR...NEXT-Schleifen
12. Zufallszahlen
13. Text bearbeiten
14. Subroutinen
15. Funktionen
16. Grafik
17. Sound
18. Felder
19. Arbeiten mit Dateien
20. Mehrfachverzweigungen mit SELECT CASE
21. EXE-Dateien erstellen
22. Tipps und Tricks
23. Wie steige ich noch tiefer in QBasic ein?
24. Liste der Beispielprogramme

1. Was ist SelfQB?

zurück zum Inhalt

2. Was ist QBasic?

zurück zum Inhalt

3. Wie bekomme ich QBasic auf meinen Computer?

• Bei Bedarf die Schriftart anpassen, um eine optimale Lesbarkeit zu erzielen
• Über [Bildschirm | Fenster] den Ablauf in einem Teilfenster wählen
• Die "Leerlaufaktivität" auf einen mittleren Wert setzen
• Bei Windows 2000/XP "Ausführen als Symbol" aktivieren und unter "Sonstiges" den Punkt "Hintergrund...immer vorübergehend aussetzen" deaktivieren
• Bei Windows 2000/XP die "DOS-kompatible Timer-Emulation" aktivieren

zurück zum Inhalt

4. Mein erstes Programm

'***********************************************************
' ERSTPROG.BAS - erstes kleines Programm fuer SelfQB
' ============
' (c) by Triton 2001/2002 *g*
'***********************************************************
CLS           'Bildschirm loeschen
texta$ = "Ich sitze hier am Computer und..."
textb$ = "...schreibe Programme, die keinen Sinn machen."
textc$ = "Doch sie sind cool - sie sind ja auch von mir!"
'
COLOR 1, 15   'blaue Schrift (=1) auf weissem Grund (=15)
LOCATE 8, 20  'Ausgabe ab Zeile 8, Spalte 20
PRINT texta$  'Inhalt von texta$ anzeigen
'
SLEEP 2       '2 sec warten
LOCATE 10, 20
COLOR 4, 6    'rote Schrift auf braunem Grund
PRINT textb$
'
SLEEP 3
COLOR 15, 1   'weisse Schrift auf blauem Grund
PRINT         'Leerzeile anzeigen
LOCATE 12, 20
PRINT textc$
SLEEP 5
END

1. CLS löscht den Bildschirm
2. Je Zeile schreibt man einen QBasic-Befehl hin. Mehrzeilige Befehle sind nicht möglich.
3. Das Hochkomma ' leitet Kommentar ein, das sind Erläuterungen zum Programm, die der QBasic-Interpreter beim Abarbeiten das Programms einfach überliest. Statt des Hochkommas kann man auch REM verwenden, das aber am Zeilenanfang stehen muss.
4. Texta$ ist eine Textvariable - die Fachleute sprechen von "Stringvariable" - und kann Textdaten speichern. Mit Texta$ = "Ich sitze hier am Computer" wird der in Anführungszeichen stehende Text in die Stringvariable Texta$ im RAM eingetragen. Die Namen von Stringvariablen müssen mit einem Dollarzeichen "$" abgeschlossen werden. Mehr über Variablen erfährst Du in Kapitel 6.
5. COLOR setzt die Farbe des Textes, der mit PRINT angezeigt wird, und nach dem Komma die Farbe des Texthintergrundes. Die Bedeutung der hinter COLOR stehenden Farbcodes erfährst Du im nächsten Kapitel. Du kannst sie auch in der QBasic- Onlinehilfe nachschlagen, indem Du mit der rechten Maustaste auf den Befehl COLOR klickst. Dadurch öffnet sich die passende Infoseite der QBasic- Onlinehilfe. Klicke dann unten im Hilfe-Fenster auf "Farbattribute". Wie Du siehst, verfügt QBasic über eine vorzügliche Onlinehilfe. Mehr dazu in Kapitel 9. Mit Esc beendest Du die Hilfe.
6. "LOCATE Zeile, Spalte" setzt die Position des Cursors auf dem Bildschirm für die anschließend folgende Textanzeige ("locate" ist das englische Wort für "lokalisieren", "Position festlegen").
7. PRINT zeigt den nachfolgenden Text an der durch LOCATE festgelegten Stelle auf dem Bildschirm an. Der Text kann direkt in Ausführungszeichen angegeben werden, wie beim obigen "Hallo Welt" - Programm, oder er kann in einer Stringvariablen, z.B. texta$, stehen. Einige Besonderheiten des PRINT- Befehls erfährst Du in Kapitel 13.
8. PRINT ohne nachfolgenden Text überspringt einfach eine Zeile, und auf dem Bildschirm erscheint eine Leerzeile, wie Du bei der letzten ausgegeben Zeile (vor textc$) sehen kannst.
9. SLEEP versetzt den Computer für die hinter SLEEP angegebenen Anzahl von Sekunden in einen schläfrigen Wartezustand und fährt danach mit der Ausführung des Programms fort. In Kapitel 11 erfährst Du, wie Du genauere und kürzere Wartezeiten erzeugen kannst.
10. END beendet das Programm und übergibt die Kontrolle wieder an die QBasic-Entwicklungsumgebung. Man kann END meist auch weglassen. Für eine saubere Programmiertechnik solltest Du es Dir aber angewöhnen, durch ein END den Abschluss Deines Programms eindeutig zu kennzeichnen.

zurück zum Inhalt

5. Farbcodes

'*****************************************************
' COLOR-1.BAS = Einsatz von Farben im QBasic-Textmodus
' ===========
' Thomas Antoni, 6.1.2004
'*****************************************************
COLOR 12, 1   'hellrote Schrift auf blauem Hintergrund
CLS           'Bildschirm loeschen d.h. in der
              'Hintergrundfarbe blau einfaerben
LOCATE 12, 30 'Cursor auf Zeile 12, Spalte 30
PRINT "Die Welt ist farbig!"
PRINT
LOCATE , 25   'Cursor auf Spalte 30
COLOR 14, 2   'gelbe Schrift auf gruenem Hintergrund
PRINT " Und hier gelb auf gruen :) "
COLOR 13       'braune Schrift
LOCATE 20, 26 'Cursor auf Zeile 20, Spalte 22
PRINT "Rosa passt zu gruen ~(ø;ø)~"
COLOR 15, 0   'normale Farben: weiss auf schwarz

zurück zum Inhalt

6. Variablen und Datentypen

Exponentialdarstellung von Gleitpunktzahlen

a! = 2 ^ 24  'Einfach lange Gleitpunktzahl 2 hoch 24
PRINT a!     'Anzeige: 1.677722E+07 entspricht 1,677722 * 10^7
b# = 1 / 1234567890 'doppelt lange Gleitpunktzahl
PRINT b#     'Anzeige: 8.10000007371D-10 entspricht 8,10000007371 * 10^(-10)

Regeln für Variablennamen

zurück zum Inhalt

7. Verzweigungen und Anwendereingaben

'*********************************************************
' INPUTIF.BAS = Demo fuer die Befehle INPUT und IF...THEN
' ===========
' Dieses QBasic-Programm demonstriert
' - Benutzer-Abfragen mit INPUT
' - Verzweigungen mit IF...THEN
'
' (c) Triton, 2002
'*********************************************************
CLS
INPUT "Wie ist Dein Name ?", name$
INPUT "Wie ist das Wetter heute? (gut), oder (schlecht) "; wetter$
'
IF wetter$ = "gut" THEN text$ = ", dann gehen Sie lieber raus an die Luft!"
'
IF wetter$ = "schlecht" THEN text$ = ", dann bleiben Sie lieber hier!"
PRINT "Ok, "; name$; text$
SLEEP

1. Anwendereingaben abfragen mit INPUT
   Der Text in den Anführungszeichen "" wird als Frage gestellt, und die Antwort in der Variable hinter dem "," gespeichert. Vielleicht ist Dir aufgefallen, dass bei der 2. Frage ein "?" erscheint, obwohl es gar nicht in der Frage steht. Das kommt vom Semikolon ";" hinter der Frage. Wenn Du das Semikolon durch ein Komma ersetzt, wie bei der ersten Frage, dann erscheint kein Fragezeichen.
   
   
2. Verzweigung mit IF...THEN
   Ganz offensichtlich bewirkt hier die IF...THEN - Anweisung eine Unterscheidung der Handlung. So wird bei der Eingabe von gutem Wetter ein anderer Text ausgegeben als bei schlechtem Wetter.
   
   
3. Erweitertes PRINT
   PRINT wird hier anders verwendet als zuvor. Statt nur den Text in "" Zeichen auszugeben, wird auch der in den String-Variablen name$ und text$ hinterlegte Text 'rangehängt. Hätten wir übrigens statt einem ";" ein "," überall in die PRINT Anweisung gebracht, wären alle Textteile durch Tabulatorenweiten, also 14- er Zeichenschritte, voneinander getrennt! Mehr dazu in Kapitel 11.
   
   
4. SLEEP ohne Zeitangabe
   Auch SLEEP wird hier anders verwendet als vorher. Da kein Zeitraum zum Warten angegeben wurde, wartet SLEEP einfach bis eine beliebige Taste gedrückt wird. Aber Vorsicht: SLEEP löscht den Tastaturpuffer nicht; das kann im nachfolgenden Programm zu unvorhergesehenen Effekten führen. In Kapitel 8 wirst Du eine professionellere Methode zum Warten auf einen Tastendruck kennenlernen, die diesen Mangel nicht hat.
   
   
5. IF...THEN- Abfrage
   Die interessanteste Anweisung ist hier IF...THEN... Damit wollen wir uns jetzt näher beschäftigen.
   
   Diese Anweisung lässt sehr vielfältig benutzen. Ihre Syntax kommt fast der eines normalen Satzes gleich:
   
   IF <Bedingung> THEN <Anweisungen> ELSE <Anweisungen>
   
   bzw. auf Deutsch:
   
   WENN dies erfüllt ist MACHE dasunddas ANSONSTEN diesesundjenes
   
   Dieses doch recht einfache Prinzip kann in sehr vielen Varianten eingesetzt werden, sodass sich alle möglichen Dinge unterscheiden lassen. Es ist für einen Programmierer wichtig, das Prinzip dieser Anweisung zu verstehen. Beherrscht man diese, dann tut man sich nämlich bei vielen Programmieraufgaben erheblich leichter! Jetzt wollen wir zu einem weiteren Beispiel kommen, das die Möglichkeiten des IF Befehls gut demonstriert:

'***********************************************************************
' IFTHEN.BAS = QBasic-Demo fuer IF...THEN-Abfragen
' ==========
' (c) Triton, 2002
'***********************************************************************
CLS
start:
INPUT "Welchen Wochentag haben wir heute (1=Montag...7=Sonntag): ", tag%
IF tag% < 1 OR tag% > 7 THEN
  PRINT "Ungueltige Eingabe!"
  GOTO start
END IF
IF tag% > 0 AND tag% < 6 THEN
  PRINT "Werktag!"
ELSE
  PRINT "Wochenende!"
END IF
END

1. Mehrzeiliger IF...THEN-Befehl
   Zum Einen bemerkt man, dass die THEN Anweisungen (also alles nach THEN) nicht in die gleiche Zeile geschrieben werden muss, sondern auch mehrere Zeilen lang sein kann. In solchen Fällen muss die IF...THEN -Anweisung durch eine extra Zeile mit END IF abgeschlossen werden.
   
   Es gibt noch sehr viele weitere Verwendungsmöglichkeiten der IF Anweisung, die aber alle zu erklären würde zweifelsohne den Rahmen sprengen. Wenn Du Lust hast, kannst Du ja mal in der QBasic -Onlinehilfe unter "IF" stöbern. Gib dazu in der Entwicklungsumgebung einfach "if" ein und betätige dann die F1-Taste.
   
   
2. Unbedingte Sprünge mit GOTO
   Außerdem entdeckt man GOTO mit einer nachfolgenden "Sprungmarke", in diesem Fall "start". GOTO veranlasst den Computer, den normalen Programmablauf zu verlassen und zu dem Befehl nach der Sprungmarke zu springen. Von dort macht er mit der Programmausführung weiter. Natürlich kann man mit GOTO auch in einen späteren Teil des Programms springen, der noch nicht regulär abgearbeitet wurde. Du solltest GOTO sparsam verwenden. Bei wildem Hin- und Hergespringe verlierst Du sonst schnell die Übersicht. Für die Namen von Sprungmarken gelten dieselben Regeln wie für Variablennamen; siehe Kapitel 6.
   
   
3. LINE INPUT ermöglicht Eingaben, die Kommas enthalten
   Kommen wir zurück zu Abfragen, die den Benutzer betreffen. Wir hatten am Anfang bereits den Befehl INPUT verwendet. Wenn Du schon etwas mit ihm herumexperimentierst hast, hast Du vielleicht bemerkt, dass INPUT keine Kommas "," in den Antworten erlaubt. Das mag auf den ersten Blick zwar nicht schlimm erscheinen, kann Dir aber später große Probleme bereiten. Deshalb lernen wir jetzt noch eine Alternative kennen: LINE INPUT. Dieser Befehl unterscheidet sich von INPUT nur insofern, dass er auch "," in der Antwort toleriert. Die Syntax ist sonst die gleiche.
   
   
4. Vergleichsoperatoren
   Nach IF erscheinen meist Vergleichoperationen. QBasic kennt die folgenden Vergleichsoperatoren:

   IF a = b THEN   ' a gleich b
   IF a < b THEN   ' a kleiner als b
   IF a > b THEN   ' a größer als b
   IF a <= b THEN  ' a kleiner oder gleich b
   IF a >= b THEN  ' a größer oder gleich b
   IF a <> b THEN  ' a ungleich b

5. logische Verknüpfungen AND und OR
   Vergleichoperationen können durch die logischen Verknüfungen AND und OR miteinander kombiniert werden z.B.:
   
   IF a >= 10 AND a <= 20 THEN PRINT "a liegt zwischen 10 und 20"
IF a < 10 OR a > 20 THEN PRINT "a liegt außerhalb des Bereichs 10...20"
   
   Das erste Beispiel ist eine UND-Verknüpfung. Der THEN-Zweig wird durchlaufen, wenn a größer oder gleich 10 UND kleiner oder gleich 20 ist.
   
   Das zweite Beispiel beinhaltet eine ODER-Verknüpfung. Der THEN-Zweig wird durchlaufen, wenn a kleiner als 10 ODER größer als 20 ist.

zurück zum Inhalt

8. Schleifen und Abfrage von Einzeltasten-Betätigungen

'*************************************
' TIME.BAS = Uhrzeitanzeige in QBasic
' ========
' Die aktuelle Uhrzeit wird solange
' in Zeile 12, Spalte 35 angezeigt,
' bis der Anwender die Esc-Taste
' dueckt (ASCII-Code 27).
'
' (c) Thomas Antoni, 7.1.2004
'*************************************
DO
  LOCATE 12, 35: PRINT TIME$
LOOP UNTIL INKEY$ = CHR$(27)
END

1. INKEY fragt eine Tastenbetätigung ab
   Hier wird abgefragt, ob die ESC Taste gedrückt wurde, die den ASCII-Code 27 hat. Die in der Klammer angegebenen Codes für die einzelnen Tasten kann man in der QB Hilfe nachlesen unter [Hilfe | Inhalt | ASCII Zeichencodes].
2. Mehrere Befehle in einer Zeile
   Wie Du in der 2. Zeile siehst, kannst Du mehrere QBasic-Befehle auch ausnahmsweise in eine Zeile schreiben, wenn Du sie durch Doppelpunkte voneinander trennst. Mach bitte sparsamen Gebrauch davon. Es erhöht nicht gerade die Übersichtlichkeit, besonders wenn die Zeilen dadurch länger als ca. 60 Zeichen werden.
3. Uhrzeit ermitteln mit TIME$
   Die in QBasic eingebaute Systemfunktion TIME$ ermittelt die aktuelle Uhrzeit und liefert diese als Textstring zurück. In der Schleife wird die Uhrzeit immer wieder neu in der Bildschirmzeile 12 ab Spalte 35 angezeigt.
4. Schleife mit DO..LOOP UNTIL
   Der zwischen DO und LOOP... stehende Programteil wird solange durchlaufen, BIS (engl. "UNTIL") der Computer ein Betätigen der Esc-Taste erkennt. Diese Programmsequenz stellt eine so genannte "Schleife" dar.
5. Weitere Schleifenkonstruktionen
   QBasic bietet sehr flexible Schleifenkonstruktionen. Es gibt z.B. die folgenden 5 verschiedenen Methoden, die Zahlen von 0 bis 100 anzuzeigen:

'*****************************************************
' LOOP.BAS = 5 Möglichkeiten, die Zahlen von
' ========   0 bis 100 anzuzeigen
' (c) Thomas Antoni, 7.11.03 - 30.1.2004
'*****************************************************
'
'------- Zaehlschleife mit FOR...NEXT ---------------
'Bei jedem Durchlauf wird i% um 1 erhöht
FOR i% = 1 TO 100  'Zaehlschleife: 
  PRINT i%
NEXT
'
'------ Fussgesteuerte DO...LOOP WHILE Schleife -----
SLEEP
COLOR 13
i% = 0
DO
  i% = i% + 1
  PRINT i%
LOOP WHILE i% < 100 'Ruecksprung nach DO, wenn die
                    'Fortsetzbedingung erfuellt
'------ Fussgesteuerte DO...LOOP UNTIL Schleife ------
SLEEP
COLOR 14
i% = 0
DO
  i% = i% + 1
  PRINT i%
LOOP UNTIL i% = 100 'Ruecksprung nach DO solange bis
                    'die Abbruchbedingung erfuellt ist
'------ Kopfgesteuerte DO UNTIL...LOOP Schleife ------
SLEEP
COLOR 8
i% = 0
DO UNTIL i% = 100   'Schleife durchlaufen bis die
  i% = i% + 1       'Abbruchbedingung erfuellt ist
  PRINT i%
LOOP
'
'------ Kopfgesteuerte DO WHILE...LOOP Schleife ------
SLEEP
COLOR 10
i% = 0
DO WHILE i% < 100  'Schleife solange durchlaufen bis 
  i% = i% + 1      'die Abbruchbedingung erfuellt ist
  PRINT i%
LOOP

zurück zum Inhalt

9. Die QBasic-Onlinehilfe

zurück zum Inhalt

10. Wartezeiten erzeugen

'***************************************************************
' TIMER.BAS = Erzeugung von Wartezeiten
' =========
' Der Anwender gibt eine Wartezeit in sec ein.
' Anschliessend wird die TIMER-Funktion
' verwendet, um den Programmablauf fuer diese
' Zeit anzuhalten. Wenn die Zeit abgelaufen
' ist, ertoent ein Piepston.
'
' (c) Thomas Antoni, 12.11.2003
'****************************************************************
CLS
PRINT "Gib eine Wartezeit in [sec] ein; ";
PRINT "Nachkommastellen erlaubt....t = ";
INPUT t!
starttime! = TIMER                  'Startzeit merken
'
DO
  PRINT TIMER - starttime!          'abgelaufene Zeit anzeigen
LOOP UNTIL TIMER > starttime! + t!  'Warteschleife
'
PRINT "Wartezeit ist abgelaufen"
BEEP
END

zurück zum Inhalt

11. Mathe-Funktionen und FOR...NEXT-Schleifen

x = a + b   'Addition
x = a - b   'Subtraktion
x = a * b   'Multiplikation
x = a / b   'Division
x = SQR(a)  'Quadratwurzel von a
x = a^b     'Exponentialfunktion x = a hoch b
x = a^(1/b) 'allgemeine Wurzelfunktion b-te Wurzel aus a
x = ABS(a)  'Betragsbildung "Absolutwert von a"
x = LOG(a)  'Natürlicher Logarithmus von a (zur Basis e)
x = SIN(a)  'Sinus (a im Bogenmaß; 360° entspricht 2 * Pi)
x = COS(a)  'Cosinus (a im Bogenmaß)
x = TAN(a)  'Tangens (a im Bogenmaß)
a = ATN(x)  'Arcus Tangens, Umkehrfunktion des Tangens, ergibt den Winkel a,
            'dessen Tangens = x ist, im Bogenmaß

'*******************************************************
' MathDemo.bas = Kleines QBasic Mathe-Demoprogramm
' ============
' Fuer die Zahlen i=1 bis zwanzig werden folgende
' Berechnungen durchgefuehrt und die Ergebnisse
' angezeigt:
' - Wurzel aus i
' - i hoch 2
' - 2 hoch i
' - sin (i)  ;i im Grad (2*Pi = 360 Grad)
'
' (c) Thomas Antoni, 24.10.2003 - 30.1.2004
'*******************************************************
'
CLS
Pi = 3.1416 ' Kreiskonstante
PRINT " i", "Wurzel(i)", "i^2", "2^i", "sin(i)"
PRINT
FOR i = 1 TO 20
  PRINT i, SQR(i), i ^ 2, 2 ^ i, SIN(i * 2 * Pi / 360)
  'der Klammerausdruck nach SIN rechnet den Winkel
  'i vom Gradmass (0..360 Grad ins Bogenmass (0..2*Pi) um
NEXT i
SLEEP
END

1. FOR...NEXT-Schleife
   Dieses Programm enthält einen bisher noch nicht näher behandelten Schleifenbefehl, nämlich die FOR...NEXT-Schleife. Beginnend beim Anfangswert "1" wird nach jedem Schleifendurchlauf die Schleifenvariable i um "1" erhöht und die Schleife erneut durchlaufen. Das Programm verlässt die Schleife nachdem sie mit dem Endwert i=20 durchlaufen wurde. Anschließend wird die Verarbeitung mit dem Befehl SLEEP hinter der Schleife fortgesetzt.
   
   Die FOR-Schleife eignet sich besonders gut, wenn man die genaue Anzahl der Schleifendurchgänge schon kennt.
   
   Der FOR...NEXT-Befehl hat noch einige Spezialitäten. Die Beschreibung dazu kannst Du Dir in der QBasic-Onlinehilfe anzeigen lassen. Tippe dazu in der Entwicklungsumgebung einfach "for" ein und betätige dann die F1-Taste.
   
   
2. Variablennamen ohne Typkennzeichen
   Die Variable "i" hat im Namen keinen angehängten Kennbuchstaben für den Datentyp. In solchen Fällen nimmt QBasic den Datentyp SINGLE an (einfach lange Gleitpunktzahl). Wenn Ganzzahlen für eine Aufgabe ausreichen, solltest immer ein Typenkennzeichen verwenden, z.B. % für INTEGER- Werte. Das macht Deine Programme wesentlich schneller.
   
   
3. Besonderheiten des PRINT-Befehls
   Du hast bestimmt die wohlgeordnete Bildschirmanzeige des Programms MathDemo.bas bewundert. Soll der PRINT Befehl mehrere Textstücke anzeigen, so werden diese normalerweise durch Semikolons voneinander getrennt, z.B.
   
   t$ = "sel": PRINT "Wie"; t$ 'Anzeige erfolgt als "Wiesel"
   
   Dabei erfolgt die Anzeige ohne trennende Leerzeichen, also im Beispiel als "Wiesel". Ersetzt Du das Semikolon durch ein Komma, so werden dagegen nach jedem Textstück die Spalten bis zum nächsten Tabulatorschritt mit Leerzeichen aufgefüllt. Ein Tabulatorschritt setzt den Ausgabe- Cursor auf den Beginn des nächsten 14er- Spaltenbereichs, also auf die 15., 29., 43., 57. oder 71. Spalte. Ersetze doch mal spaßeshalber in der obigen Befehlszeile das Semikolon durch ein Komma:
   
   t$ = "sel": PRINT "Wie", t$ 'Anzeige erfolgt als "Wie___________sel"
   
   Wie Du siehst, erfolgt die Ausgabe von "sel" ab der 15. statt der 4. Spalte. Die "tabulierte" Anzeige ist sehr nützlich für Anzeigen in Tabellenform, wie das obige Programm MathDemo.bas zeigt.
   
   Es gibt noch eine weitere Besonderheit beim PRINT-Befehl: Normalerweise wird nach einer Bildschirmausgabe per PRINT- Befehl ein Zeilenvorschub eingefügt. Steht am Ende des PRINT-Befehls aber ein Semikolon, dann unterbleibt der Zeilenvorschub, und ein nachfolgender weiterer PRINT-Befehl zeigt die Zeichen bündig zur ersten Anzeige in derselben Zeile an.
   
   Beispiel:
   PRINT "DU ": PRINT "Esel" 'Anzeige in 2 Zeilen
PRINT "DU";: PRINT "Esel" 'Anzeige in 1 Zeile
   
   Der feine Unterschied liegt, wie gesagt, in dem Semikolon.

zurück zum Inhalt

12. Zufallszahlen

'************************************************************************
' WUERFEL.BAS = Elektronischer Wuerfel
' ===========
' Bei jeder Tastenbetaetigung wird eine Zufallszahl zwischen 1 und 6
' erzeugt und angezeigt.
' (c) Thomas Antoni, 28.10.2003 - 7.11.2003
'************************************************************************
CLS                               'Bildschirm loeschen
DO
  RANDOMIZE TIMER                 'Zufallszahlengenerator initialisieren
  Wuerfelzahl% = INT(RND * 6) + 1 'ganzzahlige Zufallszahl zwischen 1 u.6
  PRINT Wuerfelzahl%
  DO
    taste$ = INKEY$
  LOOP WHILE taste$ = ""          'Warten auf Tastenbetaetigung
LOOP UNTIL taste$ = CHR$(27)      'Wiederholung bis Esc-Taste betaetigt
END

zurück zum Inhalt

13. Text bearbeiten

'*****************************************************************************
' TEXTBEAR.BAS = Textbearbeitung mit QBasic - die wichtigsten Befehle
' ============
' Dies Programm demonstriert die wichtigsten QBasic-Befehle zum
' Manipulieren von Zeichenketten (Strings). Als Beispiel-String dient das
' Wort "Wiesel". Nach der Erklaerung des jeweiligen Befehls folgt
' immer jeweils ein Anwendungsbeispiel.
'
' (c) Thomas Antoni, 7.1.2004 - 12.2.2004
'*****************************************************************************
CLS
t$ = "Wiesel" 'Die Befehle sind sowohl auf String-Konstanten (z.B. "Wiesel")
              'als auch auf String-Variablen (z.B. t$) anwendbar
'
'---- t$ = t1$ + t2$ -> Strings zusammenfuegen
c$ = "Wie" + "sel"
PRINT c$                  'Ergebnis: "Wiesel"
'
'---- LEFT$(String$, n) -> Liefert n Zeichen links aus einem String zurueck
PRINT LEFT$("Wiesel", 5)  'Ergebnis: "Wiese"
'
'---- RIGHT$(String$, n) -> Liefert n Zeichen rechts aus einem String zurueck
PRINT RIGHT$(t$, 4)       ' Ergebnis: "Esel"
'
'---- MID$(String$, m, n) -> Liefert n Zeichen ab dem m-ten Zeichen zurueck
PRINT MID$("Wiesel", 3, 2) 'Ergebnis: "se"; das m-te Zeichen zaehlt mit
'
'---- MID$(String$, m, n) = Ersatzstring$ -> n Zeichen eines Strings ab
'---- Zeichenposition m durch einen Ersatzstring ersetzen; ideal zum Ersetzen
'---- von Textpassagen durch einen anderen Text!
a$ = "Wiesel"
MID$(a$, 3, 2) = "rb"      'MID$ steht hierbei links von e. Gleichheitszeichen
PRINT a$                   'Ergebnis: "Wirbel"; "es" wird durch "rb" ersetzt
'
'---- LTRIM$(String$)  -> Entfernt fuehrende Leerzeichen aus einem String
PRINT LTRIM$("   Wiesel")  'Ergebnis: "Wiesel" ohne Leerzeichen
'
'---- RTRIM$(String$) -> Entfernt am Ende e.Strings stehende Leerzeichen
PRINT RTRIM$("Wiesel   ")  'Ergebnis: "Wiesel" ohne Leerzeichen
'
'---- INSTR(m, String$, Suchstring$) -> Sucht einen Suchstring in einem String
'------ ab dem m-ten Zeichen und meldet die Zeichenposition des ersten
'------ gefundenen Strings zurueck bzw. 0, wenn der Suchstring nicht gefunden
'------ wurde; ideal zum Suchen von Text!
PRINT INSTR(1, "Wiesel", "sel")  'Ergebnis: "4" = Zeichenposition von "sel"
'
'---- LCASE$ -> Gross- in Kleinbuchstaben umwandeln (nicht für Umlaute)
PRINT LCASE$("Wiesel")      'Ergebnis: "wiesel"
'
'---- UCASE$ -> Klein- in Grossbuchstaben umwandeln (nicht für Umlaute)
PRINT UCASE$("Wiesel")      'Ergebnis: "WIESEL"
'
'---- STR$ -> Numerischen Wert in String umwandeln
b$ = STR$(1 / 3)
PRINT "Ergebnis: "; b$      'Ergebnis: .3333333
'
'---- VAL -> String in numerischen Wert umwandeln
PRINT VAL(".5") * 4         'Ergebnis: 2 (4 x 0,5)
'
'---- SPACE$(n) -> Liefert einen String mit n Leerzeichen
PRINT "Wie"; SPACE$(2); "sel"  'Ergebnis: "Wie__sel" mit 2 Leerzeichen
'
'---- STRING$(n, Text$) -> Liefert einen String, der n mal das erste Zeichen
'------- des angegebenen Textes enthaelt
PRINT STRING$(5, "Wiesel")      'Ergebnis: "WWWWW"
'
'---- LEN(String$) -> Liefert die Zeichenanzahl des angegebenen Strings
PRINT LEN("Wiesel")             'Ergebnis: 6
'
'---- ASC(String$) -> Liefert den ASCII-Code des ersten String-Zeichens
PRINT ASC("Wiesel")             'Ergebnis: 87 = ASCII-Code von "W"

zurück zum Inhalt

14. Subroutinen

'********************************************
' SUBQ.BAS - Subroutine zur Quadratbildung
' ========
' (c) Thomas Antoni, 29.10.2003
'********************************************
DECLARE SUB Quadrat (i%) 'SUB deklarieren
'
CLS
FOR i% = 1 TO 20
  CALL Quadrat(i%)  'Subroutine aufrufen
NEXT
SLEEP
END
'
SUB Quadrat (i%)    'Subroutine dedefinieren
  PRINT i% ^ 2
END SUB             'Rueckkehr zum Hauptprogram

zurück zum Inhalt

15. Funktionen

'***************************************************
' FUNCQ.BAS - Funktion zur Quadratbildung
' =========
' (c) Thomas Antoni, 30.10.2003
'***************************************************
DECLARE FUNCTION Quadrat% (i%) 'FUNCTION deklarieren
'
CLS
FOR i% = 1 TO 20
  PRINT Quadrat%(i%)   'FUNCTION aufrufen
NEXT
SLEEP
END
'
FUNCTION Quadrat% (i%) 'FUNCTION definieren
  Quadrat% = i% ^ 2 'Wertzuweisung an die Funktion
                    'Ruecksprung zum Hauptprogramm
END FUNCTION 'und i% uebergeben

zurück zum Inhalt

16. Grafik

'********************************************************
' GRAFIK.BAS = Kleine Demo der wichtigsten Grafikbefehle
' ==========
' Dieses QBasic-Programm zeigt ein Mondgesicht auf dem
' Bildschirm an und demonstriert damit die folgenden
' Grafikbefehle:
' - CIRCLE = Kreis zeichnen
' - PAINT  = Flaeche ausfuellen
' - LINE   = Linie zeichnen
' - PSET   = Bildpunkt zeichnen
'
' (c) Thomas Antoni, 31.10.2003 - 8.1.2004
'********************************************************
SCREEN 9 'VGA-Grafikbildschirm mit 640x350 Pixeln
COLOR 1  'Blauer Bildschirmhintergrund
CLS      'Bildschirm ruecksetzen und blau einfaerben
CIRCLE (320, 175), 150, 14  'Kopf malen
 'Kreis um Mittelpunkt M=(320|175) mit Radius r=150 Pixel
 'und der Randfarbe 14=gelb zeichnen
PAINT (320, 175), 4, 14      'Kopf rot fuellen
 'Kreis ab Mittelpunkt mit der Farbe 4 (=rot) ausmalen
 'bis die gelbe Randfarbe (14) erreicht wird
LINE (260, 130)-(290, 130), 14
 'Linke Augenbraue als Linie von (260|130) nach (290|130)
 'mit Linienfarbe gelb (14) zeichnen
LINE (350, 130)-(380, 130), 14
 'rechte Augenbraue
LINE (320, 150)-(320, 200), 14
 'Nase
LINE (270, 235)-(370, 235), 14
 'Mund
PSET (275, 140), 14
 'linkes Auge als Bildpunkt (275|140) mit der Farbe
 'gelb (14) zeichnen
PSET (365, 140), 14
 'rechtes Auge
SLEEP
END

1. SCREEN n
   Bildschirmmodus n = 0 ... 13 aktivieren
2. CIRCLE (x%, y%), r%, f%
   Kreis mit dem Mittelpunkt (x%|y%), dem Radius r% und der Randfarbe r% zeichnen (zu dem Farbcode f% siehe Kapitel 5)
3. PAINT (x%, y%), f%, fr%
   Fläche ausgehend von dem Punkt (x%|y%) mit der Farbe f% ausfüllen, solange bis die Randfarbe fr% erreicht wird
4. LINE (x1%, y1%)-(x2%, y2%), f%
   Linie zeichnen zwischen den Punkten (x1%|y1%) und (x2%|y2%) in der Farbe f%
5. PSET (x%, y%), f%
   Bildpunkt zeichnen an der Stelle (x%, y%) mit der Farbe f%

zurück zum Inhalt

17. Sound

• BEEP  - erzeugt einen Piepston
• PLAY  - spielt eine oder mehrere Noten der Tonleiter
• SOUND - erzeugt einen Ton wählbarer Frequenz und Länge

Der PLAY-Befehl

'********************************************************
' ENTCHEN.BAS = "Alle meine Entchen" mit QBasic spielen
' ===========
'
' (c) Thomas Antoni, 2.11.2003
'********************************************************
PLAY "MFT160O3L8cdefL4ggL8aaaaL2gL8aaaaL2gL8ffffL4eeL8ggggL4c"
SLEEP
END

- M{F | B} - alle folgenden Noten im Vordergrund | Hintergrund abspielen.
          Bei der Vordergrundbearbeitung hält das Programm an, bis der Play-
          Befehl abgearbeitet ist. Bei der Hintergrundbearbeitung wird während
          der Soundausgabe das nachfolgende Programm fortgesetzt
- {A|B|...|G|} - Note a, h, c, d, e, f oder g der Tonleiter in der
          aktuellen Oktave spielen
- O<n%> - aktuelle Oktave für die folgenden Noten festlegen (n=0...6)
- L<q%> - Länge der nachfolgenden Töne festlegen (q=1-64; Tonlänge = 1/q;
          1 ist eine ganze Note; Vorbesetzung: q = 4 ==> 1/4 Note)
- P<q%> - Pausendauer zwischen den nachfolgenden Töne festlegen (q=1-64;
          Pausendauer = 1/q; Vorbesetzung: q = 4 ==> 1/4 Note)
- T<q%> - Tempo der nachfolgenden Noten in Viertelnoten/min festlegen;
          (q=32-255); Vorbesetzung: q= 128
- MS    - alle nachfolgenden Noten in Staccato spielen (kurz und abgehackt,
          nicht mit dem nächsten Ton verbunden)
- ML    - alle nachfolgenden Noten in Legato spielen (lang und getragen,
          mit der nächsten Note verbunden)
- MN    - alle nachfolgenden Noten wieder normal spielen (nicht Staccato
          oder Legato)

- PLAY          "MB ML T160 O1 L2 gdec P2 fedc"
       im Hinter- |  |   |  |   |   |   |   |
        grund   --+  |   |  |   |   |   |   +-- letzte 4 Noten
       Legato -------+   |  |   |   |   +------ 1/2 Notenlänge Pause
       Tempo 160 --------+  |   |   +---------- erste 4 Noten
       1.Oktave ------------+   +-------------- Notenlänge: 1/2 Note

Der SOUND-Befehl

'********************************************
' SIRENE.BAS = Demo des QBasic-Befehls SOUND
' ==========
' Dieses Programm erzeugt einen Sirenenklang
' (c) Winfried Furrer, 2000
'********************************************
ton = 780
bereich = 650
FOR zaehler1 = 1 TO 6
  FOR zaehler2 = bereich TO -bereich STEP -4
    SOUND ton - ABS(zaehler2), .3
    zaehler2 = zaehler2 - 2 / bereich
  NEXT zaehler2
NEXT zaehler1

zurück zum Inhalt

18. Felder

   FOR i% = 0 TO 100
     PRINT Alter%(i%)
   NEXT i%

'*****************************************************
' FELD.BAS - Felder bearbeiten in QBasic
' ========
' Dies Programm demonstriert die Bearbeitung
' von Feldern in QBasic. Der Anwender wird
' aufgefordert, 3 Zahlen einzugeben. Diese werden
' im Feld z%(2) abgelegt. Anschliessend
' berechnet das Programm die Quadratwerte der
' Zahlen und zeigt sie an
'
' (c) Thomas Antoni, 4.11.2003 - 8.1.2004
'*****************************************************
DIM z%(2)  'Feld mit den 3 Feldelementen z%(0)...z%(2)
           'deklarieren bzw. "dimensionieren"
CLS
PRINT "Gib drei Zahlen von 1 bis 100 ein"
'
'*** Zahlen eingeben *********************************
FOR i% = 0 TO 2  'Schleife ueber alle Feldelemente
  PRINT "Gib die "; i%; ". Zahl ein: ";
  INPUT z%(i%)
NEXT
'
'*** Quadratzahlen berechnen und anzeigen ************
FOR i% = 0 TO 2
  PRINT "z("; i%; ") ^2 = "; z%(i%) ^ 2
NEXT
SLEEP
END

zurück zum Inhalt

19. Arbeiten mit Dateien

'************************************************
' DATEI.BAS = Dateibearbeitung mit QBasic
' =========
' Dieses Programm demonstriert, wie man einen
' kleinen Text in die Datei c:\tmp.txt
' hineinschreibt und wieder ausliest. Diese
' Datei muss nach Beendigung des Programms
' von Hand geloescht werden.
'
' (c) Thomas Antoni, 4.11.2003
'************************************************
'
'-- Datei schreiben --
CLS
OPEN "c:\tmp.txt" FOR OUTPUT AS #1
INPUT "Gib Deinen Namen ein "; name$
WRITE #1, name$
CLOSE #1
'
'--- Datei lesen ---
OPEN "c:\tmp.txt" FOR INPUT AS #1
INPUT #1, t$
CLOSE #1
PRINT
PRINT "Du hast Folgendes eingegeben: "; t$
SLEEP
END

1. OPEN <Dateiname$> FOR OUTPUT AS #<Dateinummer>
   Damit wird die Datei zum Schreiben geöffnet und ihr für die weitere Bearbeitung eine Dateinummer zwischen 1 und 255 zugewiesen. ACHTUNG: Exisitiert die Datei bereits, dann wird ihr Inhalt beim Öffnen komplett gelöschet!
   
   
2. WRITE #<Dateinummer> , <Variable-1> [, Variable-2, ...]
   Dieser Befehl schreibt den Inhalt einer oder mehrerer Variablen in die Datei, nach der letzten Variablen gefolgt von einem Zeilenvorschub. Text wird immer in Anführungszeichen abgespeichert und numerische Werte in ASCII- Text- Form. In der Datei erscheinen die Variablen dann ebenfalls durch Kommas getrennt.
   
   
3. CLOSE [#<Dateinummer>]
   Wenn Du das Schreiben oder Lesen beenden willst, musst Du die Datei jeweils ordnungsgemäß schließen. CLOSE ohne Dateinummer schließt alle offenen Dateien.
   
   
4. OPEN <Dateiname$> FOR INPUT AS #<Dateinummer>
   Dieser Befehl öffnet die Datei zum Lesen.
   
   
5. INPUT #<Dateinummer>, <Variable-1> [, Variable-2, ...]
   Aus der Datei wird eine Zeile gelesen und die dort durch Kommas getrennten Bestandteile in die einzelnen Variablen eingetragen. Anmerkung: Zum Schreiben und Lesen von Text, der Kommas enthalten kann, verwendet man PRINT und LINE INPUT statt WRITE und INPUT; siehe QBasic- Kochbuch.
   
   Das Lesen und Schreiben der Zeilen ist nur nacheinander ("sequentiell") möglich. Eine Zeile mitten in der Datei lässt sich nicht direkt auslesen. Das ist nur mit einem anderen Dateityp, der "Direktzugriffsdatei" (Random-Datei) möglich. Auf die Details und auf die verschiedenen Dateitypen wollen wir hier nicht weiter eingehen. Die Komplett- Info zur Dateibearbeitung mit QBasic erhältst Du in meinem QBasic- Kochbuch, das auf www.qbasic.de zum Herunterladen bereitsteht.

zurück zum Inhalt

20. Mehrfachverzweigungen mit SELECT-CASE

'*****************************************************
' CASE-1.BAS - Beispiel 1 fuer den SELECT CASE Befehl
' ==========
' Es wird eine Schulnote als Zahl 1...6 abgefragt
' und in eine Textnote "sehr gut...ungenuegend"
' umgewandelt und angezeigt.
'
' von SM, 22.10.03
'*****************************************************
CLS
INPUT "Gib deine Note ein (1...6): ", Note%
SELECT CASE Note%
  CASE 1: PRINT "sehr gut"
  CASE 2: PRINT "gut"
  CASE 3: PRINT "befriedgend"
  CASE 4: PRINT "ausreichend"
  CASE 5: PRINT "mangelhaft"
  CASE 6
    PRINT "ungenuegend"
    PRINT "Die Versetzung ist gefaehrdet!!!"
  CASE ELSE: PRINT "Diese Note gibt es nicht."
END SELECT

'*****************************************************
' CASE-2.BAS - Beispiel 2 fuer den SELECT CASE Befehl
' ==========
' Dies Beispiel zeigt einige spezielle Moeglickeiten
' des SELECT CASE Befehls
'
' von Thomas Antoni, 6.1.2004 - 1.2.2004
'*****************************************************
CLS 'Bildschirm loeschen
INPUT "Gib eine Zahl zwischen 0 und 10 ein"; z
SELECT CASE z
  CASE 0: PRINT "Eingabewert ist 0"
  CASE 1 TO 8
    PRINT "Eingabewert liegt zwischen 1 und 8"
  CASE 9, 10: PRINT "Eingabewert ist 9 oder 10"
  CASE IS < 0
    PRINT "Falsche Eingabe. Eingabewert ist negativ!"
  CASE ELSE
    PRINT "Falsche Eingabe. Eingabewert zu gross!"
END SELECT

'******************************************************
' CASE-3.BAS - Beispiel 3 fuer den SELECT CASE Befehl
' ==========
' Dies Beispiel zeigt, wie man mit Hilfe des SELECT
' CASE Befehls ein Tastenmenue aufbauen kann.
'
' (c) Thomas Antoni, 9.1.2004 - 1.2.2004
'*****************************************************
DO
CLS
PRINT "Was willst Du tun?"
PRINT " (a)   = Schlafen"
PRINT " (b)   = Essen"
PRINT " (c)   = Fernsehen"
PRINT " (Esc) = Abbruch"
PRINT "Waehle die gewuenschte Aktion (Taste a, b, c oder Esc)"
DO: taste$ = INKEY$: LOOP WHILE taste$ = ""
'Warten auf die Betaetigung einer beliebigen Taste
PRINT
'
SELECT CASE taste$
  CASE "a": PRINT "Du hast Schlafen gewaehlt"
  CASE "b": PRINT "Du hast Essen gewaehlt"
  CASE "c": PRINT "Du hast Fernsehen gewaehlt"
  CASE CHR$(27)   'Esc betaetigt -> Programm beenden
    PRINT " ... und Tschuess!"
    SLEEP 2       '2 sec warten
    END           'Programm beenden bei Esc-Taste
  CASE ELSE
    PRINT "Fehler! Nur die Tasten a, b, c und Esc sind erlaubt!"
    PRINT "Wiederhole bitte die Eingabe"
END SELECT
PRINT
PRINT "... zurueck zum Hauptmenue mit beliebiger Taste";
DO: LOOP WHILE INKEY$ = ""
LOOP

• Durch die Verwendung von INKEY$ statt INPUT ist nach Eintippen des Buchstabens keine zusätzliche Betätigung der Eingabetaste erforderlich. Du kannst statt der Buchstaben natürlich auch Ziffern verwenden. Das ist oft noch ergonomischer.
• Das ganze Menü steht in einer DO...LOOP- Schleife. Daher landet der Anwender nach Abarbeitung eines Menüpunktes wieder in der Menüauswahl und kann einen anderen Punkt wählen, ohne das Programm dafür verlassen und neustarten zu müssen.
• Eingabefehler werden abgefangen, und bei Betätigung einer falschen Taste erfolgt eine Fehlermeldung und ein Rücksprung zur Menüauswahl.
• Es wird auch ein Menüpunkt für den Programm-Abbruch per Esc-Taste angeboten. Viele Anfänger- Programme kranken leider daran, dass man sie nicht in jeder Situation mit Esc abbrechen kann. Das verärgert den Anwender und nimmt ihm die Lust, das Programm weiterzuverwenden.

zurück zum Inhalt

21. EXE-Dateien erstellen

• Starte den QuickBasic-Compiler QB.EXE
• Lade das BAS-Programm mit [Datei | Programm laden...]
• Kompiliere Dein BAS-Programm mit [Ausführen | EXE-Datei erstellen... | (.) selbständige EXE-Datei | EXE erstellen und beenden]
• Die .EXE-Datei wird jetzt erzeugt und im QB 4.5 Programmverzeichnis abgelegt
• Die gleichnamige .OBJ-Datei kann ohne Bedenken gelöscht werden

• QB /L
• QB /L meinprog.bas oder
• QB.exe /L qb.qlb /run meinprog.bas

zurück zum Inhalt

22. Tipps und Tricks

QBasic mit 50 statt 25 Zeilen starten

  WIDTH 80, 50 'VGA-Auflösung mit 80 Spalten und 50 Zeilen
  COLOR 0, 7   'Schwarze Schrift auf hellgrauem Grund
  CLS          'Bildschirm löschen

Dein Programm ist abgestürzt? Kein Problem!

1. Du drückst [STRG + PAUSE], um zur QBasic-Entwicklungsumgebung zurückzukehren, ohne Informationen zu verlieren.
2. Wenn das Programm immer bei einer INPUT oder LINE INPUT Abfrage stehen bleibt, kannst Du es mit [STRG + C] abbrechen. Informationen gehen nicht verloren, da man zu QB zurückkehrt
3. Falls man sich im Vollbildmodus befindet, kann man mit [ALT]+[TAB] zum Windows- Desktop zurückkehren und das Programm auf Betriebssystemebene beenden. Nicht gespeicherte Veränderungen im Quellspracheprogramm gehen dabei allerdings verloren.

QB-Programme mit MS Word ausdrucken

zurück zum Inhalt

23. Wie steige ich noch tiefer in QBasic ein?

• Adok's Way to QBasic - Hervorragender großer deutscher QBasic-Kurs von Claus-Dieter Volko, Wien. Mit 51 Beispielprogrammen, 68 Seiten.
• "Das QBasic-Kochbuch" - eine Bauanleitung für QBasic-Programme für Fortgeschrittene mit kompletter QBasic-Befehlreferenz, gegliedert nach Anwendungsgebieten, viele Beispiele, ca. 36 Seiten
• "QB-MonsterFAQ" - eine gigantische Sammlung mit über 500 der am häufigsten zu QBasic gestellten Fragen und deren Antworten. Mit einer sehr übersichtlichen Navigation. Da bleibt fast keine Deiner Fragen unbeantwortet. Ausgedruckt wäre das ein Buch mit weit über 1200 Seiten!

zurück zum Inhalt

24. Liste der Beispielprogramme

zurück zum Inhalt