Crashkurs für QBasic und QuickBASIC (2024)

Die Geschichte von BASIC beginnt 1960. Die Herren Kemmeny und Kurtz stellen die erste Version vor. Bis heute ist BASIC berüchtigt als Sprache mit der Programme entstehen, die schwer lesbar und voller Fehler (Bugs) sind, eine schlechte Bedienung enthalten, sehr langsam sind usw. Diese Vorurteile stammen alle aus der Zeit der Homecomputer. Und die waren bekanntlich ziemlich dürftig ausgestattet. 40 KB RAM und schnecken- langsame Prozessoren gab es da! Das ist natürlich kein Vergleich zu den Resourcen heutiger PCs. Die Programmierer waren damals also gezwungen durch Tricks Anweisungen zu sparen. Das führte schon bald zum sogenannten "Spagetticode" der häufig so extrem unübersichtlich war, dass die Programmierer ihn selber kaum noch verstanden. Und gerade dieser "Spagetticode" ist auch der Grund dafür, dass BASIC- Dialekte auch heute noch bei vielen Informatik- Professoren indiskutabel sind. Und gerade weil BASIC fast jeder hatte, gab es auch mehr BASIC-Spagetti :). Wäre z.B Pascal die vorherrschende Sprache geworden, hätte es genauso Pascal-Spagetti gegeben. Auch die Bedienung von BASIC selber war früher sehr schlecht.

Das alles hat sich aber mit Erscheinen der Microsoft-BASIC- Varianten QuickBasic und QBasic entscheidend geändert. Nun steht eine sehr leistungsfähige Entwicklungsumgebung zur Verfügung. Ein weiteres Argument gegen BASIC war der geringe Sprachumfang. Das kann man QBasic/QB aber nicht mehr anlasten. Dinge wie Prozeduren, Unterprogramme, Einbindung von Assembler und C, Hardware- Programmierung und Ähnliches sind nun selbstverständlich. Bei etwas Disziplin kann man sauber, übersichtlich und ohne Spagetticode programmieren. Du siehst also: BASIC ist ein modernes Entwicklungssystem und beliebter denn je. Die alten Vorurteile gegen BASIC treffen alle nicht mehr zu. Vor allem ist BASIC eine Sprache mit Zukunft, denn es gibt immer mehr und leistungsfähigere Dialekte. Besondes erwähnenswert sind hier Blitz Basic, PureBasic, DarkBasic, PowerBASIC und VisualBasic.

Heute wird QBasic hauptsächlich von Programmier- Einsteigern und im IT-Unterricht der Schulen verwendet. Stelle bitte nicht all zu hohe Ansprüche daran, und versuche nicht, ein Spiel wie Quake 3 oder einen Internet-Browser damit zu programmieren. QBasic ist nach wie vor die ideale Sprache um die Grundlagen des Programmierens zu lernen. Alles, was Du mit QBasic lernst, kannst Du beim Aufstieg zu einem anderen BASIC-Dialekt oder zu einer ganz anderen Programmierprache sehr gut brauchen.

zurück zum Inhalt

3. Wie bekomme ich QBasic auf meinen Computer?

Kopiere die Dateien auf Deine Festplatte, z.B. in den Ordner "C:\QBASIC\". Bei der Gelegenheit solltest Du auch gleich einen Unterordner für Deine selbst erstellten QBasic-Programme anlegen, z.B. "C:\QBASIC\PROGS\.

Jetzt noch schnell eine Verknüpfung auf dem Desktop zu QBASIC.EXE eingerichtet und fertig ist die Installation.

Wenn Du willst, kannst Du im Windows-Eigenschaften-Dialog einige Optimierungen durchführen. Klicke dazu mit der rechten Maustaste auf QBasic.exe. Dort solltest Du die folgenden Anpassungen machen:

• 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

print "Hallo Welt"

Wenn Du die erste Zeile mit der Eingabetaste abschließt, siehst Du, dass das QBasic- Befehlsschlüsselwort "print" sich automatisch in ein groß geschriebenes "PRINT" verwandelt. Diese automatische "Syntaxkontrolle" ist gerade für Einsteiger eine sehr angenehme Eigenschaft von QBasic. Du siehst jederzeit sofort, ob Du die Befehle richtig hingeschrieben hast. Wenn ein Befehl sich nicht in Großbuchstaben verwandelt, muss irgend etwas faul sein.

Wähle jetzt den Menüpunkt [Ausführen | Start] und schwuppdiwupp führt QBasic das Programm aus: Auf dem Bildschirm erscheint der Text "Hallo Welt". Gratulation: Du hast soeben Dein allererstes QBasic-Programm erfolgreich geschrieben und ausgeführt. Diesen Tag solltest Du Dir ganz dick im Kalender ankreuzen. Heute ist der Beginn Deiner Programmierer-Laufbahn :)

Um die genaue Bedeutung des Befehls PRINT... wollen wir uns erstmal nicht kümmern. Das wird später noch im Detail erklärt.

Mit einer beliebigen Tastenbetätigung kehrst Du zur Entwicklungsumgebung zurück. Da ich Dich für sehr gebildet halte ;-), denke ich, dass wir gleich mit etwas Schwierigerem weitermachen können. Zum Beispiel mit dem folgendem kleinen Progrämmchen:

'***********************************************************' ERSTPROG.BAS - erstes kleines Programm fuer SelfQB' ============' (c) by Triton 2001/2002 *g*'***********************************************************CLS 'Bildschirm loeschentexta$ = "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 20PRINT texta$ 'Inhalt von texta$ anzeigen'SLEEP 2 '2 sec wartenLOCATE 10, 20COLOR 4, 6 'rote Schrift auf braunem GrundPRINT textb$'SLEEP 3COLOR 15, 1 'weisse Schrift auf blauem GrundPRINT 'Leerzeile anzeigenLOCATE 12, 20PRINT textc$SLEEP 5END

Wir können aus diesem Beispiel Folgendes lernen:

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.

Jeder Befehl hat eine sogenannte Syntax. Dieser Begriff bezeichnet ganz einfach den schematischen Grundaufbau eines Befehls. Wird die Syntax falsch angewendet, so funktioniert der Befehl entweder gar nicht oder nicht so wie er soll. Das kann man gut mit der Grammatik eines Satzes vergleichen: "Oder richtig ist Satz das hier?" *g*. Bei den meisten Syntaxfehlern, wie etwa "SLEEP texta$", zeigt QBasic beim Beenden der Zeile sofort eine aussagekräftige Fehlermeldung an.

zurück zum Inhalt

5. Farbcodes

Und in dem folgenden Programm wollen wir gleich ein wenig mit Farbenherumspielen:

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

zurück zum Inhalt

6. Variablen und Datentypen

Es gibt mehrere Typen von Variablen. Im letzten Abschnitt hast Du die Stringvariablen kennengelernt, die durch ein an den Variablennamen angehängtes "$" gekennzeichnet werden und die Text enthalten. Dann gibt es die sogenannten Integer- Variablen, die ganze Zahlen von -32768 bis 32768 (2^15) beinhalten. Integer- Variablen werden durch das nachfolgende Prozentzeichen % gekennzeichnet - z.B. otto%. Dann gibt es die langen Ganzzahlen, die von - 2.147.483.647 bis 2.147.483.647 (2^31) reichen. Sie werden durch die Typbezeichnung & gekennzeichnet. Die nächst größere Kategorie sind die Komma- Variablen einfacher Genauigkeit (Typbezeichung = !) und doppelter Genauigkeit (#). Diese reichen bis zu astronomischen Größen mit jeweils 8 bzw. 16 Nachkommastellen. Benutze immer den niedrigsten Variablentyp der für Deine Anwendung ausreicht, also bitte nicht immer Variablen doppelter Genauigkeit verwenden. Integer-Variablen lassen sich am schnellsten verarbeiten.

Und hier noch eine kleine Zusammenfassung der QBasic-Datentypen mit Beispielenfür die Variablennamen:

Exponentialdarstellung von Gleitpunktzahlen

Beispiele:

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

Regeln für Variablennamen

zurück zum Inhalt

7. Verzweigungen und Anwendereingaben

Dies lernen wir im folgenden Abschnitt, ebenso, wie wir den Programmbenutzer in das Geschehen eingreifen lassen können. Stellen wir uns vor, wir schreiben ein kleines Programm, das den Benutzer fragt, wie er heißt und wie das Wetter heute ist. Auf die letztere Frage soll entweder mit "gut", oder "schlecht" geantwortet werden. Das Programm soll die Benutzereingabe dann durch eine passende Bildschirmausgabe kommentieren. Ein solches Programm sieht etwa so aus:

'*********************************************************' 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'*********************************************************CLSINPUT "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, diediesen 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'***********************************************************************CLSstart:INPUT "Welchen Wochentag haben wir heute (1=Montag...7=Sonntag): ", tag%IF tag% < 1 OR tag% > 7 THEN PRINT "Ungueltige Eingabe!" GOTO startEND IFIF tag% > 0 AND tag% < 6 THEN PRINT "Werktag!"ELSE PRINT "Wochenende!"END IFEND

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 folgendenVergleichsoperatoren:

   IF a = b THEN ' a gleich bIF a < b THEN ' a kleiner als bIF a > b THEN ' a größer als bIF a <= b THEN ' a kleiner oder gleich bIF a >= b THEN ' a größer oder gleich bIF 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 folgenden5 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öhtFOR i% = 1 TO 100 'Zaehlschleife: PRINT i%NEXT''------ Fussgesteuerte DO...LOOP WHILE Schleife -----SLEEPCOLOR 13i% = 0DO i% = i% + 1 PRINT i%LOOP WHILE i% < 100 'Ruecksprung nach DO, wenn die 'Fortsetzbedingung erfuellt'------ Fussgesteuerte DO...LOOP UNTIL Schleife ------SLEEPCOLOR 14i% = 0DO i% = i% + 1 PRINT i%LOOP UNTIL i% = 100 'Ruecksprung nach DO solange bis 'die Abbruchbedingung erfuellt ist'------ Kopfgesteuerte DO UNTIL...LOOP Schleife ------SLEEPCOLOR 8i% = 0DO UNTIL i% = 100 'Schleife durchlaufen bis die i% = i% + 1 'Abbruchbedingung erfuellt ist PRINT i%LOOP''------ Kopfgesteuerte DO WHILE...LOOP Schleife ------SLEEPCOLOR 10i% = 0DO WHILE i% < 100 'Schleife solange durchlaufen bis i% = i% + 1 'die Abbruchbedingung erfuellt ist PRINT i%LOOP

Mit UNTIL ("BIS") oder WHILE ("WÄHREND", "SOLANGE WIE") gibt man an, ob dienachfolgende Bedingung als Abbruchbedingung oder als Fortsetzbedingungfungieren soll.

zurück zum Inhalt

9. Die QBasic-Onlinehilfe

Die QBasic-Online-Hilfe hat eine sehr komfortable Navigation. Ähnlich wie auf einer Webseite erhältst Du in jeder Situation Zusatzinformationen über eine Fülle von Text-Links, denen Du per Doppelklick mit der linken Maustaste oder - noch bequemer - per Einfachklick mit der rechten Maustaste folgen kannst.

Willst Du mehr zu einem bestimmten Befehl wissen, dann brauchst Du nur das Befehlsschlüsselwort in der Entwicklungsumgebung einzutippen und dann die F1- Taste zu betätigen. Oder Du klickst einfach mit der rechten Maustaste auf den fraglichen Befehl im Quelltext.

Wenn Du Dir einen Überblick darüber verschaffen willst, welche Befehle für eine bestimmte Problemstellung hilfreich sein könnten, dann wählst Du am besten [Hilfe | Inhalt | Schlüsselwort nach Kontext]. Daraufhin erscheint eine nette, nach Funktionen gegliederte Liste aller QBasic- Befehle. Klickst Du mit der rechten Maustaste auf einen der aufgelisteten Befehle, dann öffnet sich ein Hilfefenster mit detaillierten Informationen zu diesem Befehl.

Bei QuickBasic 4.5 ist die Onlinehilfe sogar noch wesentlich ausführlicher und auch etwas anders organisiert. Dort gelangst Du zu der nach Funktionen gegliederten Befehlsliste über [Hilfe | Themen | Schlüsselwortlisten | Doppelklick auf das gewünschte Thema].

zurück zum Inhalt

10. Wartezeiten erzeugen

Genauere und kleinere Wartezeiten lassen sich mit dem TIMER-Befehl realisieren.

TIMER liefert den aktuellen Stand der Systemuhr zurück und zeigt die Anzahl der seit Mitternacht vergangenen Sekunden an. TIMER hat eine Auflösung von 18,2 "Takten" pro sec. D.h. TIMER wird alle 0,056 sec (= 56 ms) um den Wert 0,056 erhöht. Wartezeiten unter 0,056 sec sind daher mit TIMER nicht realisierbar.

Der Timer liefert Gleitpunktwerte vom Typ SINGLE zwischen 0.000 und 86400.000 sec (entspricht den 24 Stunden von 00:00:00h ... 23:59:59h). Bei der Realisierung von Stoppuhren und Countdown-Timern ist der Rücksprung vom Maximalwert 86400.000 auf 0.000 um Mitternacht zu berücksichtigen.

Das folgende Progrämmchen zeigt, wie Du Wartezeiten mit TIMER realisierenkannst.

'***************************************************************' 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'****************************************************************CLSPRINT "Gib eine Wartezeit in [sec] ein; ";PRINT "Nachkommastellen erlaubt....t = ";INPUT t!starttime! = TIMER 'Startzeit merken'DO PRINT TIMER - starttime! 'abgelaufene Zeit anzeigenLOOP UNTIL TIMER > starttime! + t! 'Warteschleife'PRINT "Wartezeit ist abgelaufen"BEEPEND

zurück zum Inhalt

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

x = a + b 'Additionx = a - b 'Subtraktionx = a * b 'Multiplikationx = a / b 'Divisionx = SQR(a) 'Quadratwurzel von ax = a^b 'Exponentialfunktion x = a hoch bx = a^(1/b) 'allgemeine Wurzelfunktion b-te Wurzel aus ax = 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ß

Winkel im [Bogenmaß] = Winkel in [Grad] * 6,283 / 360

Die Arcus-Umkehrfunktionen des sin, cos und cot unterstützt QBasic nicht direkt. Sie sind aber leicht über einfache Formeln zu berechnen. Weitere Infos dazu findest Du in meinem QBasic-Kochbuch, das aufwww.qbasic.de zum Herunterladen bereitsteht.

Und nun ein kleines Beispielprogramm, das in einer kleinen Tabelle für die Zahlen i von 1 bis 20 die Wurzel, den Quadratwert, die Potenz i hoch 2 und den Sinus von i (i im Gradmaß) angibt:

'*******************************************************' 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'*******************************************************'CLSPi = 3.1416 ' KreiskonstantePRINT " i", "Wurzel(i)", "i^2", "2^i", "sin(i)"PRINTFOR 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) umNEXT iSLEEPEND

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 derSchleifendurchgä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, wiedas 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

Was ist aber nun, wenn Du eine ganzzahlige Zufallszahl zwischen 1 und nbenötigst? Dann gehst Du einfach nach dem folgenden Rezept vor:

'************************************************************************' 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 loeschenDO 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 TastenbetaetigungLOOP UNTIL taste$ = CHR$(27) 'Wiederholung bis Esc-Taste betaetigtEND

Je Tastendruck wird eine Zufallszahl angezeigt, solange bis der Anwender die Esc-Taste betätigt. Dafür sorgen die letzten 5 Zeilen. Diese solltest Du Dir genau durchlesen, denn sie bilden die Problemlösung für eine sehr häufige Aufgabenstellung: Eine Befehlsfolge soll bei jedem Tastendruck wiederholt und mit Esc abgebrochen werden.

Und wie erzeugt man eine ganzzahlige Zufallszahl zwischen min% und max%?Das geht nach der folgenden Formel:

RANDOMIZE TIMER 'Zufallsgenerator initialisieren
PRINT INT(RND * (max% - min% + 1)) + min%
'ganzzahlige Zufallszahl zwischen min% und max%

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'*****************************************************************************CLSt$ = "Wiesel" 'Die Befehle sind sowohl auf String-Konstanten (z.B. "Wiesel") 'als auch auf String-Variablen (z.B. t$) anwendbar''---- t$ = t1$ + t2$ -> Strings zusammenfuegenc$ = "Wie" + "sel"PRINT c$ 'Ergebnis: "Wiesel"''---- LEFT$(String$, n) -> Liefert n Zeichen links aus einem String zurueckPRINT LEFT$("Wiesel", 5) 'Ergebnis: "Wiese"''---- RIGHT$(String$, n) -> Liefert n Zeichen rechts aus einem String zurueckPRINT RIGHT$(t$, 4) ' Ergebnis: "Esel"''---- MID$(String$, m, n) -> Liefert n Zeichen ab dem m-ten Zeichen zurueckPRINT 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. GleichheitszeichenPRINT a$ 'Ergebnis: "Wirbel"; "es" wird durch "rb" ersetzt''---- LTRIM$(String$) -> Entfernt fuehrende Leerzeichen aus einem StringPRINT LTRIM$(" Wiesel") 'Ergebnis: "Wiesel" ohne Leerzeichen''---- RTRIM$(String$) -> Entfernt am Ende e.Strings stehende LeerzeichenPRINT 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 umwandelnb$ = STR$(1 / 3)PRINT "Ergebnis: "; b$ 'Ergebnis: .3333333''---- VAL -> String in numerischen Wert umwandelnPRINT VAL(".5") * 4 'Ergebnis: 2 (4 x 0,5)''---- SPACE$(n) -> Liefert einen String mit n LeerzeichenPRINT "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 enthaeltPRINT STRING$(5, "Wiesel") 'Ergebnis: "WWWWW"''---- LEN(String$) -> Liefert die Zeichenanzahl des angegebenen StringsPRINT LEN("Wiesel") 'Ergebnis: 6''---- ASC(String$) -> Liefert den ASCII-Code des ersten String-ZeichensPRINT ASC("Wiesel") 'Ergebnis: 87 = ASCII-Code von "W"

zurück zum Inhalt

14. Subroutinen

Tippe z.B. mal Folgendes in der QBasic-Entwicklungsumgebung ein:

CLS
FOR i% = 1 TO 20
CALL Quadrat(i%)
NEXT
SLEEP
END

Dies ist das Hauptprogramm, das 20 mal per CALL- Befehl die Subroutine "Quadrat" aufruft und an diese den "Parameter" i% übergibt.

Um jetzt die Subroutine "Quadrat" einzugeben, wählst Du in der Entwicklungsumgebung den Menüpunkt [ Bearbeiten | Neue SUB | Name: "Quadrat" ]

In dem sich jetzt öffnenden Fenster gibst Du die folgenden Befehle ein:

SUB Quadrat (i%)
PRINT i% ^ 2
END SUB

Startest Du nun das fertige Programm mit F5 oder [Ausführen | Start], so erscheint auf dem Bildschirm eine Liste der Quadratzahlen von 1^2 = 1 bis 20^2 = 400. Wie Du siehst, ist die als Parameter übergebene Variable i% auch in der Subroutine zugreifbar. Die anderen im Hauptprogramm verwendeten Variablen sinddagegen in der Subroutine unbekannt.

Das Gesamtprogramm sieht dann so aus:

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

In der Entwicklungsumgebung wechselst Du zwischen dem Hauptprogramm und den SUBs über den Menüpunkt [Ansicht | SUBs... ] oder die F2-Taste. Das ist eine sehr komfortable Sache, weil Du die einzelnen SUBs ganz bequem durchblättern und annavigieren kannst. Einmal ausgetestete Subroutinen kannst Du in Deinen verschiedensten Programmen immer wieder verwenden, und Du kannst auch auf eine Reihe von SUB- Sammlungen anderer Programmierern zurückgreifen. Einige gute SUB- Kollektionen für häufig vorkommende Programmierprobleme findest Du auf www.qbasic.deunter [Download | Sonstiges]. Scheue Dich nicht, die dort verfügbaren SUBs in eigene Programme einzubauen. Warum solltest Du das Rad zum x-ten Mal neu erfinden? Auch die Profi-Programmierer gehen so vor, um Zeit und Geld zu sparen.

Es lässt sich übrigens auch mehr als ein Übergabeparameter an eine Subroutine übergeben. Dann werden die einzelnen Parameter in der Klammer durch Kommas voneinander getrennt aufgeführt, z.B.

CALL Multiplikation (Ergebnis%, Faktor1%, Faktor2%)

Für die Namen von Subroutinen und Funktionen gelten dieselben Regeln wie für Variablennamen; siehe Kapitel 6.

zurück zum Inhalt

15. Funktionen

Da die Funktion wie eine Variable benutzt wird, muss sie auch einen Datentyp haben, damit QBasic weiß, wie es den zurückgelieferten Wert interpretieren muss.

Im Folgenden findest ein Programmbeispiel mit einer FUNCTION "Quadrat%" vom Typ INTEGER, erkenntlich an dem Typkennzeichen "%". Es handelt sich dabei um eine Abwandlung des oben stehenden Programms SUBQ.BAS.

'***************************************************' FUNCQ.BAS - Funktion zur Quadratbildung' =========' (c) Thomas Antoni, 30.10.2003'***************************************************DECLARE FUNCTION Quadrat% (i%) 'FUNCTION deklarieren'CLSFOR i% = 1 TO 20 PRINT Quadrat%(i%) 'FUNCTION aufrufenNEXTSLEEPEND'FUNCTION Quadrat% (i%) 'FUNCTION definieren Quadrat% = i% ^ 2 'Wertzuweisung an die Funktion 'Ruecksprung zum HauptprogrammEND FUNCTION 'und i% uebergeben

zurück zum Inhalt

16. Grafik

Für Grafikanzeigen verwendest Du die Screenmodi (Bildschirmbetriebsarten) SCREEN 1 bis 13, die sich hinsichtlich der Aufösung und der Anzahl Farben unterscheiden. Mehr Infos findest Du in der QBasic-Hilfe unter [Index | SCREEN].

Am beliebtesten sind die Screenmodi 9, 12 und 15. Wir wollen hier den Bildschirmmodus SCREEN 9 verwenden, der eine VGA/EGA- Auflösung von 640 x 350 Pixeln bietet. Jeder Bildschirmpunkt ist dabei über seine x- und y- Koordinaten ansprechbar. Die linke obere Ecke hat die Koordinaten (x=0, y=0) und die rechte untere Ecke (x=639, y=199). Du siehst also, die y-Achse zählt von oben nach unten und nicht wie aus der Schule gewohnt von unten nach oben.

Das folgende kleine Programm GRAFIK.BAS zeichnet ein Mondgesicht auf den Bildschirm und demonstriert dabei einige wichtige Grafikbefehle von QBasic:

'********************************************************' 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 PixelnCOLOR 1 'Blauer BildschirmhintergrundCLS 'Bildschirm ruecksetzen und blau einfaerbenCIRCLE (320, 175), 150, 14 'Kopf malen 'Kreis um Mittelpunkt M=(320|175) mit Radius r=150 Pixel 'und der Randfarbe 14=gelb zeichnenPAINT (320, 175), 4, 14 'Kopf rot fuellen 'Kreis ab Mittelpunkt mit der Farbe 4 (=rot) ausmalen 'bis die gelbe Randfarbe (14) erreicht wirdLINE (260, 130)-(290, 130), 14 'Linke Augenbraue als Linie von (260|130) nach (290|130) 'mit Linienfarbe gelb (14) zeichnenLINE (350, 130)-(380, 130), 14 'rechte AugenbraueLINE (320, 150)-(320, 200), 14 'NaseLINE (270, 235)-(370, 235), 14 'MundPSET (275, 140), 14 'linkes Auge als Bildpunkt (275|140) mit der Farbe 'gelb (14) zeichnenPSET (365, 140), 14 'rechtes AugeSLEEPEND

Die einzelnen Grafikbefehle sind im Kommentar erläutert. Hier nochmal dieZusammenfassung:

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"SLEEPEND

Der Befehls-String$ kann die folgenden Bestandteile haben:

- 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

Es handelt sich dabei um sehr einfache Art der Soundausgabe: Es wird ein Tonmit der angegebenen Frequenz der Dauer in Systemtakten von je 0,056 sec(= 56 ms) ausgegeben.

Beispiel 1 - 2000Hz-Ton für 336ms (6*56ms) spielen:
SOUND 2000, 6

Beispiel 2 - Motorengeräusch ausgeben bis eine beliebige Taste gedrückt wird:
DO
SOUND 192, 0.5 'Motorengeraeusch
SOUND 188, 0.5
LOOP WHILE INKEY$ = ""

Beispiel 3 - Sirene

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

Außerdem demonstriert das Programm noch eine Spezialität des FOR...NEXT-Befehls: STEP -4 bewirkt, dass das Programm die Schleife bei jedem Durchlauf mit einem um 4 reduzierten Wert von zaehler2 durchläuft.

zurück zum Inhalt

18. Felder

Bevor man ein Feld benutzen kann, muss man es über den DIM-Befehl "dimensionieren". Mit

DIM Alter%(100)

wird z.B. ein Feld namens "Alter%" vom Typ INTEGER mit 101 Feldelementen (Indices 0 ... 100) dimensioniert, das etwa das Lebensalter von 101 Personen enthalten kann. Die Indices beginnen also normalerweise mit "0" und nichtmit "1".

Felder sind hervorragend geeignet zum Speichern und Bearbeiten von Datenbanken,Messdatenreihen, Tabellen, Vektoren, Matritzen und ähnlichen gegliederten Datensammlungen. Der Feldindex steht in einer auf den Feldnamen folgendenKlammer.

Einzelne Feldelemente lassen sich über ihren Index bequem und effizient auch in Schleifen bearbeiten, meist in einer FOR...NEXT-Schleife, weil die Anzahl der Bearbeitungsschritte ja oft bereits vorher festliegt. Die folgende Befehlssequenz zeigt beispielsweise alle 101 im Feld Alter%(100) gespeicherten FeldelementeAlter%(0) bis Alter%(100) auf dem Bildschirm an:

 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"CLSPRINT "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%) ^ 2NEXTSLEEPEND

DIM C#(9,4)

wird z.B. ein zweidimensionales Feld vom Typ DOUBLE (doppelt lange Gleitpunktzahl) deklariert (man sagt auch "dimensioniert"), das 10 Blöcke (Index 0...9) mit je 5 Feldelementen enthält (von 0 bis 4). Der Zugriff auf das 3. Element des 4. Blockes erfolgt so:

C# (2,3) = 86 .

Dieses zweidimensionale Feld kannst Du Dir quasi als eine Tabelle mit 10 Zeilen à 5 Spalten vorstellen. Mit dem obigen Befehl trägst Du den Wert 86 in Zeile 3, Spalte 4 ein.

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 --CLSOPEN "c:\tmp.txt" FOR OUTPUT AS #1INPUT "Gib Deinen Namen ein "; name$WRITE #1, name$CLOSE #1''--- Datei lesen ---OPEN "c:\tmp.txt" FOR INPUT AS #1INPUT #1, t$CLOSE #1PRINTPRINT "Du hast Folgendes eingegeben: "; t$SLEEPEND

Die einzelnen Befehle wollen wir hier nun kurz erläutern:

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 jeweilsordnungsgemäß 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 aufwww.qbasic.dezum Herunterladen bereitsteht.

zurück zum Inhalt

20. Mehrfachverzweigungen mit SELECT-CASE

IF Note% = 1 THEN ...
IF Note% = 2 THEN ...
IF Note% = 3 THEN ...
IF Note% = 4 THEN ...

Wesentlich effizienter und übersichtlicher ist aber die Verwendung des SELECT CASE Befehls. SELECT CASE heißt zu deutsch "wähle einen Fall aus". Es wird abhängig vom Wert der Selektor- Variablen eine Fallunterscheidung gemacht.

'*****************************************************' 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'*****************************************************CLSINPUT "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

Sollte die Selektor-Variable einen Wert haben, für den kein CASE vorgesehen wurde, dann springt das Programm zum CASE-ELSE-Block. Wenn CASE ELSE fehlt, dann wird der gesamte SELECT-CASE-Block einfach übersprungen.

Wenn ein CASE-Block nur aus einem Befehl besteht, dann kannst Du ihn zusammen mit dem Befehl "CASE..." in eine Zeile schreiben - durch einen Doppelpunkt voeneinander getrennt. Besteht ein CASE-Block aus mehreren Befehlen, dann werden diese ab der Zeile unter dem CASE n hingeschrieben, wie Du bei CASE 6 sehen kannst.

Hier noch ein paar weitere Möglichkeiten der CASE-Anweisung:

CASE "j"
CASE "j", "J"
Wenn String-Variablen auf einen Text abgefragt werden, dann denke bitte an die Anführungsstriche. Der erste CASE Block wird durchlaufen, wenn in der Selektor-Variablen ein kleines j steht, der zweite CASE Block sowohl beim kleinen j als auch beim großen J. Mit dieser Methode kann man sehr elegante Tastenmenüsrealisieren

CASE IS < 10
Bei Vergleichen muß das Schlüsselwort IS eingefügt werden. Diese Bedingung ist erfüllt, wenn die Selektor-Variable kleiner als 10 ist.

CASE 5 TO 10
Hier muß die Selektor-Variable einen Wert zwischen 5 und 10 besitzen.

Das folgende Programm zeigt einige der genannten Möglichkeiten:

'*****************************************************' 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 loeschenINPUT "Gib eine Zahl zwischen 0 und 10 ein"; zSELECT 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'*****************************************************DOCLSPRINT "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 TastePRINT'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 SELECTPRINTPRINT "... zurueck zum Hauptmenue mit beliebiger Taste";DO: LOOP WHILE INKEY$ = ""LOOP

Dieses Menü ist wesentlich eleganter programmiert als die meisten Menüs,die ich in Anfänger- Programmen sonst so finde. Es hat die folgenden Vorteile:

• 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.

taste$ = INPUT$(1) 'warten auf die Betaetigung einer beliebigen Taste

Dadurch wird ein Zeichen von der Tastatur in die Variable taste$ eingelesen und das Programm hält dafür automatisch an.

zurück zum Inhalt

21. EXE-Dateien erstellen

Lade Dir QuickBasic 4.5 Compiler z.B. vonwww.qbasic.deherunter [Rubrik "QBasic | Download | Compiler"].

Gehe wie folgt vor, um ein BAS-Programm in ein lauffähiges EXE-Programmumzuwandeln :

• 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

Aufsteiger von QBasic sollten die folgenden Hinweise beachten, um die häufigsten Einsteigerfehler zu vermeiden:

Bei Programmen, die den CALL ABSOLUTE Befehle erhalten (z.B. einige Mausroutinen), muss die QuickLibrary QB.QLB mit eingebunden werden. Starte dazu QuickBasic mit einem der folgenden Aufrufe:

• 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

@echo off
cls
qbasic.exe /h
cls


Kopiere diese Datei in das QBASIC\ -Verzeichnis und starte künftig dieseBatchdatei statt QBasic.exe.

Auch Deine Programme selber können im Textmodus (SCREEN 0) ein 50 Zeilen großes Fenster nutzen, indem Du vorne im Programm Folgendes hinschreibst:

 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

Alte MS-Word-Versionen konvertieren Textdateien, die im MS-DOS -ASCII- Zeichencode vorliegen, beim Öffnen automatisch in den Windows-ANSI-Code. Bei Word für Windows ab Version 97 ist dies leider nicht mehr der Fall. Daher werden die Umlaute und viele Sonderzeichen nicht richtig dargestellt und lassen sich nicht korrekt ausdrucken. Dies Problem ist jedoch leicht zu umgehen, wofür es zwei Lösungen gibt:

Lösung 1
Ändere die Dateierweiterung "BAS" in "ASC" (für "ASCII"). Dann konvertiert Word die Datei beim Öffnen automatisch in das Windows ANSI-Format.

Lösung 2
Der Konverter ist bereits installiert, Du musst ihn nur in Word unter [Extras | Optionen| Allgemein] mit dem Schalter "Konvertierung beim Öffnen bestätigen" aktivieren. Danach fragt Dich Word künftig beim Öffnen einer BAS oder TXT-Datei immer, in welchem Format genau diese vorliegt. "Nur Text", entspricht ANSI-Text, "MS-DOS-Text" entspricht dem bei BAS-Dateien vorliegenden ASCII-Text usw.

Jetzt kannst Du Deine BAS- Dateien korrekt ausdrucken. Du darfst sie natürlich nicht in Word abspeichern, wenn Du das ursprüngliche Format erhalten willst.Am Besten, Du erstellst für das Ausdrucken sicherheitshalber eine Kopie Deiner BAS-Datei.

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