Quick Basic: Druckversion

Ein Buch für Leute die das Programmieren erlernen wollen

Vorwort

Hallo erstmal!

Du hast sicher schon einmal den Gedanken gehabt "Ich will ein eigenes Programm schreiben!". Wahrscheinlich hast du noch keinerlei Erfahrungen auf dem Gebiet und hast die Idee daher schnell wieder verworfen.

Wir wollen dir in diesem WikiBook eine Einführung in die Welt des Programmierens geben. Als Programmiersprache wird QuickBASIC verwendet, da es eine sehr einfache Sprache ist und man schnell Ergebnisse erzielen kann.

In diesem Buch wirst du zuerst die Grundlagen erlernen (wie zum Beispiel die Textausgabe auf dem Bildschirm) und mit Übungsaufgaben dein Wissen festigen. Alle Übungen können mit dem gelernten Wissen gelöst werden, falls es dennoch Fragen geben sollte oder Unklarheiten herrschen: stell deine Fragen ruhig auf der Diskussionsseite des Kapitels. Jeder Abschnitt beinhaltet kommentierten Beispielcode, damit du die Funktionsweise bestimmter Befehle besser erklärt bekommst. In den späteren Kapiteln sollen dir fortschrittliche Themen (Datenbearbeitung, etc.) näher gebracht werden, auch hier wirst du wieder einige Übungsaufgaben und erklärten Beispielcode vorfinden.

Wir wünschen dir nun viel Spaß beim durcharbeiten dieses WikiBooks!

Wir freuen uns sehr, wenn du Verbesserungsvorschläge für uns hast oder mithilfst, dieses Buch weiter zu verbessern.

Was ist QuickBasic und woher bekommt man es?

QuickBASIC ist eine Programmiersprache der Firma Microsoft. Ausgestattet ist das Programm mit einer voll funktionsfähigen Entwicklungsumgebung mit Interpreter und Compiler, um eigene Programme in ausführbare Dateien kompilieren zu können. Die Syntax ist einfach gehalten, so dass der Code leicht zu lesen ist. Somit können auch Programmieranfänger schnell und einfach eigene Anwendungen entwickeln.

QBasic in der amerikanischen Version

1991 kam eine abgespeckte Version heraus: QBASIC 1.1. Mit dieser Version ist es nicht mehr möglich, ausführbare EXE-Dateien zu erstellen und ist daher ein reiner Interpreter. Es wurde ab 1991 mit dem Betriebssystem MS-DOS vertrieben. Außerdem lag der QBASIC-Interpreter auch Windows 98 bei.

Die Programmiersprache wird heute nicht mehr weiterentwickelt, somit ist Version 7.1 die letzte, offizielle Version (nur in englischer Sprache verfügbar). Es gibt keine Windows-Version des Programms, daher kann man mit QuickBASIC zum Beispiel die WinAPI nicht verwenden. Allerdings lassen sich QBASIC und QuickBASIC ohne Probleme unter Windows XP verwenden. Ob es unter Vista und 7 funktioniert, habe ich nocht nicht getestet. Auf der unten als erstes aufgeführten Website kann man QBASIC sowie QuickBASIC unter "Downloads" kostenlos herunterladen.

FreeBasic ist der inoffizielle Nachfolger der Programmiersprache und ist vollkommen kostenlos und Open Source. Die Syntax ist dem Original sehr ähnlich und kann echte Windows-Anwendungen kompilieren, aber auch 32-bit Anwendugen für DOS. Das Programm ist derzeit noch im Betastadium, jedoch wird es regelmäßig weiterentwickelt.

Weblinks

• QBasic.de - Die größte, deutsche Internetseite zu QBASIC, QuickBASIC und anderen BASIC-Dialekten
• Das größte, deutsche Forum über QBASIC und FreeBASIC
• FreeBasic.net - Offizielle Seite zu FreeBasic
• Deutscher Wikipedia-Eintrag zu QBasic
• Deutscher Wikipedia-Eintrag zu QuickBASIC

Zeichenerklärung

Zeichenerklärung

Dieser Abschnitt dient dazu, um in QuickBASIC verwendete Zeichen (zum Beispiel ' ) zu erklären.

• ' (Hochkomma) - Kommentarzeichen; alles was rechts von diesem Zeichen steht wird von QuickBASIC beim Programmablauf ignoriert und dient zur Dokumentation des Quellcodes (Alternativ zu ' kann auch REM geschrieben werden)
•  : (Doppelpunkt) - Trennt Befehle die in einer Zeile stehen, deklariert Label (wenn es das letzte Zeichen einer Zeichenkette ist, die am Zeilenanfang steht)
•  ? (Fragezeichen) - Kurzform zur Eingabe von PRINT (wird automatisch in PRINT umgewandelt)

Ausgabe am Bildschirm

Ausgabe mit PRINT

Mit dem Befehl PRINT kannst du Zeichenketten und/oder Werte aus Variablen auf dem Bildschirm ausgeben. Bei der Ausgabe von Zeichenketten ist zu beachten, dass der Text in "Anführungszeichen" geschrieben steht. Variablennamen dürfen im Gegensatz dazu nicht in Anführungszeichen gesetzt werden, da sonst wie normaler text der Variablenname ausgegeben wird.

Beispiel:

PRINT "Hallo, dies ist ein Text..."

a = 123  'Der Variable a den Wert 123 zuweisen
PRINT a  'Die Variable auf dem Bildschirm ausgeben

Wenn du nun mit der <F5>-Taste oder über das Menü Ausführen/Start das Programm startest, wird auf dem Bildschirm folgender Text erscheinen:

Hallo, dies ist ein Text...
 123

Du kannst diese beiden Ausgabearten auch kombinieren, indem du die einzelnen Teile durch Komma (,) oder Semikolon (;) trennst. Bei einer Trennung durch ein Semikolon wird gleich am Ende der Zeichkette weitergeschrieben, bei der Verwendung eines Kommas wird erst an der nächsten Tab-Marke weitergeschrieben.

Beispiel:

x = 512                           'Variablen einen Wert zuweisen
PRINT "Wert der Variablen x:", x  'gibt den Text und den Wert der Variablen x aus
PRINT "Quick", "Basic"
PRINT "Quick"; "Basic"

gibt folgendes aus:

LPRINT

Mit der Funktion LPRINT kannst du Daten auf dem Drucker ausgeben. Die Anwendung von LPRINT ist identisch mit der von PRINT.

ACHTUNG: Auf neuen Computern funktioniert die LPRINT-Anweisung nicht mehr. Stattdessen wird nur ein Gerätefehler gemeldet.

Übungen

• Schreibe ein Programm, welches die Namen deiner besten Freunde auf dem Bildschirm anzeigt

Bildschirm leeren mit CLS

Wir können nun zwar auf den Bildschirm etwas darstellen, aber was ist, wenn wir das vorige Beispiel mehrmals hintereinander öffnen? Richtig, die Ausgabe des vorigen Programmes wird nicht entfernt. Dafür gibt es den Befehl CLS - ausgeschrieben ClearScreen. Der Befehl leert den kompletten Bildschirminhalt und setzt den Cursor oben links in die Ecke.

Syntax:

CLS

CLS ist ein eigenständiger Befehl ohne Parameter.

Beispiel:

PRINT "Hallo, ich bin da..."

Starte das Programm mehrmals hintereinander, bis du folgendes am Bildschirm hast:

Hallo, ich bin da...
Hallo, ich bin da...
Hallo, ich bin da...
Hallo, ich bin da...
Hallo, ich bin da...

Nun modifizieren wir das Programm, indem wir über der PRINT-Zeile ein CLS einfügen. Der Code müsste danach so aussehen:

CLS 'Leere den Bildschirminhalt
PRINT "Hallo, ich bin da..."

Starte das Programm erneut mehrmals hintereinander und du wirst sehen, dass bei jedem Programmaufruf nur einmal Hallo, ich bin da... zu sehen ist.

Es ist ratsam in jedem QuickBASIC-Programm ein CLS am Anfang zu schreiben. Somit ist garantiert, dass wirklich nur das eigene Programm angezeigt wird.

Textpositionierung mit LOCATE

In QuickBASIC lassen sich alle Ausgaben auf den Bildschirm mithilfe eines Befehls positionieren. Dieser Befehl heißt LOCATE. Mit ihm kann man einen Text oder den Wert einer Variable an einer bestimmten Zeile/Spalte anzeigen lassen.

Syntax:

LOCATE Zeile, Spalte

Zur besseren Verständlichkeit ein kurzes Beispiel:

LOCATE 10, 10 'Positioniere Text an Zeile 10, Spalte 10
PRINT "Ausgabetext"

Als Ausgabe würden wir

          Ausgabetext

erhalten.

MS-DOS bzw. QuickBASIC besitzen jedoch keine unbegrenzte Anzahl an Zeilen und Spalten. Standardmäßig können maximal 25 Zeilen und 80 Spalten ausgefüllt werden. Wenn man über diese Grenze kommt, meldet die Entwicklungsumgebung eine Fehlermeldung und das Programm lässt sich nicht ausführen.

Übungen

• Schreibe ein Programm, welches den Text "Hallo, ich bin da!" an einer beliebigen Bildschirmposition anzeigt.

Textfarbe festlegen

Wie wir erfahren haben, können wir mit Hilfe des Befehls PRINT Texte, Zahlen, usw. auf dem Bildschirm darstellen und mit LOCATE positionieren. Doch das klassische Farbschema Grau-auf-Schwarz, wie man es aus DOS-Zeiten und der Windows-DOS-Shell kennt, ist doch auf Dauer langweilig, oder?

In diesem Kapitel wird erklärt, wie man auf dem Bildschirm farbige Texte ausgeben kann.

Um dies zu bewerkstelligen sehen wir uns den Befehl COLOR an. Mit Hilfe dieses Befehls können wir nicht nur die Textfarbe ändern, sondern auch den Texthintergrund anpassen.

Syntax:

COLOR Textfarbe, Hintergrundfarbe

Beispiel:

COLOR 15, 1 'Weiße Schrift auf blauen Hintergrund
PRINT "Hallo, ich bin jetzt farbig!"

Wenn wir dieses Programm ausführen, wird der Text Hallo, ich bin jetzt farbig! mit weißer Schrift auf blauen Untergrund angezeigt. Dies ist besonders praktisch, wenn man zum Beispiel das Ergebnis einer Berechnung hervorheben will.

Normal hat man 15 verschiedene Farben zur Auswahl, hierzu eine kleine Übersicht:

0 = Schwarz     4 = Rot           8 = Grau             12 = Hellrot
1 = Blau        5 = Violett       9 = Hellblau         13 = Hellviolett
2 = Grün        6 = Braun        10 = Hellgrün         14 = Gelb
3 = Zyan        7 = Weiß         11 = Hellzyan         15 = Leuchtend-Weiß

Die Hintergrundfarbe ist automatisch etwas dunkler als die Textfarbe, somit wird aus Weiß-auf-Weiß, ein Weiß-auf-Grau.

Statt festen Werten, kann man auch Variablen mit dem jeweiligen Farbcode verwenden.

Beispiel:

 Rot = 12 'Rot den Wert 12 zuweisen
 Blau = 9 'Blau den Wert 9 zuweisen
 Color Rot, Blau 'Rote Schrift auf blauen Hintergrund
 Print "Ich bin farbig!"

Die ersten zwei Zeilen übergeben den Variablen Rot und Blau jeweils einen Wert. Die dritte Zeile legt die Farben fest und die letzte gibt einen Text, in der zuvor definierten Farbe, aus.

Man kann auch Quick Basic die Farbcodes (1,2,3...) in ihrer Farbe anzeigen lassen.

Beispiel:

FOR Wdh = 1 TO 20 'Anfang FOR...NEXT Schleife; Wdh kann beliebig ersetzt werden
COLOR Wdh         'Farbe entsprechend der Wdh-ten Wiederholung
PRINT Wdh         'Zahl entsprechend der Wdh-ten Wiederholung
NEXT Wdh          'Ende FOR...NEXT Schleife

Das Ergebnis ist dann:

1

2

3

4

5

...

(die Zahlen immer in unterschiedlichen Farben)

Übungen

• Schreibe ein Programm, welches einen beliebigen Text am Bildschirm anzeigt und die Farbkombination Gelb-auf-Braun darstellt

• Schreibe ein Programm, welches deinen Vornamen in weißer Schrift und deinen Nachnamen in hellroter Schrift in Zeile 10, Spalte 15 ausgibt

Wartezeit einfügen

Nun möchten wir dir zeigen, wie man eine kleine Pause in das Programm einfügt. Wir wollen dem Programm zum Beispiel sagen Du, mach' vor der Ausgabe eine Sekunde Pause. Dies können wir mit dem Befehl SLEEP erreichen.

Syntax:

SLEEP Sekunden

Beispiel:

PRINT "Hallo, ich warte jetzt!"
SLEEP 1 'Warte eine Sekunde
PRINT "So, eine Sekunde ist um!"

Zu erst wird ein Text ausgegeben (Hallo, ich warte jetzt!), danach wird mit SLEEP eine Wartezeit von einer Sekunde aufgerufen. Die dritte und letzte Zeile gibt erneut einen Text aus (So, eine Sekunde ist um!) und zwar nach der gewünschten Wartezeit.

Wenn wir dieses Programm ausführen fällt uns auf, dass wir die Pause mit einem beliebigen Tastendruck unterbrechen können. Dies ist kein Fehler! Der SLEEP-Befehl wartet entweder bis die vorgegebene Zeit abgelaufen ist oder bis eine Taste gedrückt wird. Wir werden im Laufe dieses Buches eine andere Möglichkeit für Wartezeiten beschreiben, die diese Eigenheit nicht hat.

Wie wir oben bei der Syntax feststellen können ist der Parameter Sekunden kursiv geschrieben. Dies bedeutet, dass es ein so genannter optionaler Parameter ist. Das heißt, wir können den Parameter angeben, müssen dies aber nicht tun. Doch was ist, wenn wir den Parameter weglassen? Ganz einfach: Das Programm wartet keine bestimmte Zeit ab, sondern läuft erst nach einem Tastendruck weiter.

Beispiel:

PRINT "Drücke eine beliebige Taste..."
SLEEP 'Warte auf einen Tastendruck
PRINT "Es wurde eine Taste gedrückt!"

In der ersten Zeile wird ein Text ausgegeben (Drücke eine beliebige Taste...), in der zweiten wird der SLEEP-Befehl ohne einen Parameter aufgerufen und die letzte gibt wieder einen Text aus (Es wurde eine Taste gedrückt!).

Übungen

• Schreibe ein Programm, welches deinen Namen ausgibt
  • Es soll zwischen der Ausgabe von Vor- und Nachname eine Wartezeit von einer Sekunde eingefügt werden
  • Der Nachname soll in einer beliebigen Farbe dargestellt werden

• Schreibe ein Programm, welches den Namen deines Lieblingsfilmes ausgibt
  • Er soll in der Mitte des Bildschirms angezeigt werden (mit LOCATE)

• Schreibe ein Programm, welches vier deiner Lieblingsbands am Bildschirm ausgibt
  • Nach jeder Band soll auf einen Tastendruck gewartet werden
  • Jede Band soll farblich dargestellt werden

Eingabe von Daten

Mathematische Operatoren

Wir haben im letzten Abschnitt beschrieben, wie du Werte in Variablen schreiben kannst. In diesem Abschnitt wollen wir uns ein wenig mit mathematischen Operatoren befassen (auch arithmetische Operatoren genannt). Sehen wir uns die vier Grundrechnungsarten an:

Addition

Arithmetischer Operator: +

Syntax:

Zahl1 + Zahl2 + Zahl3 + ...

Bei dieser Funktion wird die Summe von zwei oder mehreren Zahlen gebildet.

Sehen wir uns ein einfaches Beispiel mit dem bisher gelernten an:

 Dim Zahl1 As Integer 'Zahl1 als Ganzzahl initialisieren
 Dim Zahl2 As Integer 'Zahl2 als Ganzzahl initialisieren
 Input "Zahl1: ", Zahl1 'Lies Wert für Zahl1 ein
 Input "Zahl2: ", Zahl2 'Lies Wert für Zahl2 ein
 Print "Die Summe beträgt: ";
 Color 12, 12 'Hellrot auf Dunkelrot
 Print Zahl1 + Zahl2 'Addiere die zwei Zahlen

Die ersten zwei Zeilen deklarieren zwei Variablen des Typs Integer. Danach werden den beiden Variablen Werte zugewiesen, die der Benutzer eingegeben hat. Zum Schluss wird ein Ergebnistext ausgegeben und die Summe farblich hervorgehoben. Als Anzeige auf dem Bildschirm würden wir zum Beispiel folgendes erhalten:

Zahl1: 2
Zahl2: 2
Die Summe beträgt:  4

Der +-Operator erlaubt, mehr Werte als nur zwei miteinander zu addieren, dazu wandeln wir unser Beispielprogramm etwas ab:

 Dim Zahl1 As Integer 'Zahl1 als Ganzzahl initialisieren
 Dim Zahl2 As Integer 'Zahl2 als Ganzzahl initialisieren
 Dim Zahl3 As Integer 'Zahl3 als Ganzzahl initialisieren
 Input "Zahl1: ", Zahl1 'Lies Wert für Zahl1 ein
 Input "Zahl2: ", Zahl2 'Lies Wert für Zahl2 ein
 Input "Zahl3: ", Zahl3 'Lies Wert für Zahl3 ein
 Print "Die Summe beträgt: ";
 Color 12, 12 'Hellrot auf Dunkelrot
 Print Zahl1 + Zahl2 + Zahl3 'Addiere die drei Zahlen

Als Ausgabe würden wir auf dem Bildschirm folgendes erhalten:

Zahl1: 1
Zahl2: 1
Zahl3: 3
Die Summe beträgt: 5

Die Beispiele gelten für alle folgenden Operatoren, einzig und allein die Rechenzeichen (+, -, etc.) müssen ausgetauscht werden.

Subtraktion

Arithmetischer Operator: -

Syntax:

Zahl1 - Zahl2 - Zahl3 - ...

Bei dieser Funktion wird die Differenz von zwei oder mehreren Zahlen gebildet.

Multiplikation

Arithmetischer Operator: *

Syntax:

Zahl1 * Zahl2 * Zahl3 * ...

Bei dieser Funktion wird das Produkt von zwei oder mehreren Zahlen gebildet.

Division

Arithmetischer Operator: /

Syntax:

Zahl1 / Zahl2 / Zahl3 / ...

Bei dieser Funktion wird der Quotient von zwei oder mehreren Zahlen gebildet.

Ganzzahldivision

Arithmetischer Operator: \

Syntax:

Zahl1 \ Zahl2 \ Zahl3 \ ...

Bei dieser Funktion wird der Quotient von zwei oder mehreren Zahlen gebildet. Bei der Ganzzahldivision wird das Ergebnis jedoch gerundet, und man erhält eine Ganzzahl. Alle Zahlen nach dem Komma werden bei dieser Operation abgeschnitten.

Modulo

Arithmetischer Operator: MOD

Syntax:

Zahl1 MOD Zahl2 MOD Zahl3 MOD ...

Bei dieser Funktion wird das Ergebnis einer Division gebildet. Jedoch wird hierbei der Rest der Division zurückgegeben, nicht der Quotient.

Potenz

Arithmetischer Operator: ^

Syntax:

Zahl1 ^ Zahl2 

Allgemeine Regeln

Klammern

Durch setzen von Klammern lässt sich die die Priorität von Operationen verändern.

Potenz vor Punkt vor Strich

Es werden immer zuerst Potenzen, dann Multiplikationen und Divisionen und zuletzt Additionen und Subtraktionen durchgeführt.

Von links nach rechts

Gleichberechtigte Operationen werden von links nach rechts ausgeführt.

Übungen

• Schreibe ein Programm, welches zwei Zahlen einliest und danach die vier Grundrechnungsarten mit diesen durchführt
  • Das Ergebnis jeder Berechnung soll farblich hervorgehoben werden

• Schreibe ein Programm, welches vier Zahlen einliest und danach eine Division, eine Ganzzahldivision sowie eine Modulofunktion ausführt
  • Das Programm soll nach jeder Ausgabe der jeweiligen Berechnung eine Sekunde warten
  • Das Ergebnis jeder Berechnung soll farblich hervorgehoben werden

Bedingungen

Bedingungen mit IF-ELSE

Wir haben gelernt, wie wir etwas in eine Variable speichern können und wie es auf dem Bildschirm ausgegeben wird. Auch haben wir uns angesehen, wie wir mathematische Operatoren verwenden können. In diesem Abschnitt wollen wir uns so genannte Bedingungen ansehen, ein wichtiger Bestandteil einer jeden Programmiersprache. Wir werden uns nun die Funktionsweise von IF und ELSE/ELSEIF näher ansehen.

Kurz etwas zur Theorie: Bedingungen sind nötig, um auf bestimmte Ereignisse reagieren zu können. Ein Beispiel wäre, wenn man ein Zahlenratespiel programmiert. Man würde hierfür Bedingungen benötigen für die folgenden Ereignisse:

• Die Eingabezahl ist größer als die Zufallszahl
• Die Eingabezahl ist kleiner als die Zufallszahl
• Die Eingabezahl ist die Zufallszahl

Normaler IF-Block

Syntax:

IF Bedingung THEN
   Mache dies und das
END IF

Übersetzung:

WENN Bedingung DANN
   Mache dies und das

Beispiel:

 DIM Eingabe AS INTEGER 'Variable als Ganzzahl initialisieren
 INPUT "Eingabe: ", Eingabe 'Wert in Variable schreiben
 IF Eingabe = 10 THEN 'WENN Eingabezahl IST 10 DANN
    PRINT "Eingabezahl ist 10" 
 END IF

Die erste Zeile deklariert eine Ganzzahlvariable. Die nächste Zeile speichert die Benutzereingabe in die Variable. Jetzt kommt die Bedingung: WENN die Eingabezahl 10 IST, DANN gib eine Meldung aus. Die letzte Zeile zeigt den Abschluss des Bedingungsblocks.

Als Ausgabe würde man zum Beispiel folgendes erhalten:

Eingabe: 10
Eingabezahl ist 10

IF-ELSE-Block

Wir können nun auf das Ereignis Eingabezahl ist 10 reagieren. Doch was ist, wenn wir auf das Ereignis Eingabezahl ist ungleich 10 reagieren wollen? Wir benötigen dafür einen ELSE-Block.

Syntax:

IF Bedingung THEN
   Mache dies und das, falls wahr
ELSE
   Mache dies und das, falls falsch
END IF

Übersetzung:

WENN Bedingung DANN
   Mache dies und das, falls wahr
SONST
   Mache dies und das, falls falsch

Wir verdeutlichen das ganze mit einem Beispiel:

 DIM Eingabe AS INTEGER 'Variable als Ganzzahl initialisieren
 INPUT "Eingabe: ", Eingabe 'Wert in Variable schreiben
 IF Eingabe = 10 THEN 'WENN Eingabezahl IST 10 DANN
    PRINT "Eingabezahl ist 10"
 ELSE 'SONST
    PRINT "Eingabezahl ist nicht 10"
 END IF

Die erste Zeile deklariert wieder eine Ganzzahlvariable. In der nächsten Zeile wird die Benutzereingabe in die Variable Eingabe gespeichert. Jetzt kommt wieder eine Bedingung: WENN die Eingabezahl 10 IST, DANN gib Eingabezahl ist 10 aus, SONST gib Eingabezahl ist nicht 10 aus.

Als Ausgabe hätte man dann zum Beispiel:

Zahl eingeben: 5
Eingabezahl ist nicht 10

IF-ELSEIF-Block

Nun kommen wir zu letzten IF-Möglichkeit: ELSEIF.

Syntax:

IF Bedingung THEN
   Mache dies und das
ELSEIF Bedingung THEN
   Mache dies und das
END IF

Übersetzung:

WENN Bedingung DANN
   Mache dies und das
SONST WENN Bedingung DANN
   Mache dies und das

Wie wir sehen, können wir mit ELSEIF eine weitere fixe Bedingung im IF-Block festlegen.

Zur besseren Verständlichkeit wieder ein Beispiel:

 DIM Eingabe AS INTEGER 'Variable als Ganzzahl initialisieren
 INPUT "Eingabe: ", Eingabe 'Wert in Variable schreiben
 IF Eingabe = 10 THEN 'WENN Eingabezahl IST 10 DANN
    PRINT "Eingabezahl ist 10"
 ELSEIF Eingabe = 5 THEN 'SONST WENN Eingabezahl IST 5 DANN
    PRINT "Eingabezahl ist 5"
 END IF

Die erste Zeile deklariert die bekannte Ganzzahlvariable. In der nächsten Zeile wird die Benutzereingabe in die Variable Eingabe gespeichert. Jetzt kommt unsere Bedingung: WENN die Eingabezahl 10 IST, DANN gib Eingabezahl ist 10 aus, SONST WENN die Eingabezahl 5 IST, gib Eingabezahl ist 5 aus.

Als Ausgabe hätte man dann zum Beispiel:

Zahl eingeben: 5
Eingabezahl ist 5

Wie wir sehen sind solche Bedingungen recht einfach zu realisieren. Es können natürlich auch Strings verwendet werden, es ist also auch eine Abfrage wie WENN Eingabe IST "J" DANN möglich.

IF-ELSEIF-ELSE-Block

Natürlich können auch mehrere Blöcke "kombiniert" werden um komplexere Abfragen durchzuführen.

Syntax:

IF Bedingung1 THEN
   Anweisungen
ELSEIF Bedingung2 THEN
   Anweisungen
ELSEIF Bedingung3 THEN
   Anweisungen
   .
   .
   .
ELSE
   Anweisungen
END IF

Hier werden der Reihe nach alle Bedingungen überprüft. Sobald eine davon wahr ist, werden die dazugehörigen Anweisungen ausgeführt und anschließend ans Ende des IF-Blocks gesprungen. Sind jedoch alle Bedingungen falsch, so werden die Anweisungen des ELSE-Abschnitts (sofern vorhanden) ausgeführt.

Beispiel:

 DIM zahl AS INTEGER
 INPUT "Gib eine Zahl von 1 bis 3 ein: ", zahl
 IF zahl = 1 THEN
    PRINT "eins"
 ELSEIF zahl = 2 THEN
    PRINT "zwei"
 ELSEIF zahl = 3 THEN
    PRINT "drei"
 ELSE
    PRINT "die Zahl lag nicht zwischen 1 und 3!!"
 END IF

Übungen

• Schreibe ein Programm, welches zwei Zahlen vom Benutzer verlangt, und bei den Zahlen 1 und 15 eine Meldung ausgibt.

SELECT-CASE-Anweisung

Im letzten Kapitel haben wir gelernt wie man Abfragen durchführt, dass das Programm entsprechend der Eingabe des Benutzers handeln kann. Bei komplexeren Abfragen bietet sich die SELECT-CASE-Anweisung an.

Die Syntax lautet:

SELECT CASE Testausdruck
   CASE Ausdrucksliste1
      Anweisungen
   CASE Ausdrucksliste2
      Anweisungen
      .
      .
      .
   CASE ELSE
      Anweisungen
END SELECT

Der Testausdruck kann eine beliebige Zahl oder Zeichenkette sein. Dieser wird dann der Reihe nach mit den Ausdrücken Ausdrucksliste1, Ausdrucksliste2, u. s. w. verglichen, wobei das Vergleichen beim ersten zutreffenden Ausdruck beendet wird. Diese Ausdrücke können eine der folgenden drei Formen haben

• Element1 [, Element2 ...]
• Element1 TO Element2
• IS Vergleichsoperator Element

Vergleichsoperator ist ein beliebiger Verleichsoperator (<, <=, >, >=, <>, =). Mehr dazu im Kapitel Operatoren.

So, das war jetzt erstmal genug Theorie. Greifen wir noch einmal auf das letzte Beispiel des vorigen Kapitels zurück. Dieses wollen wir jetzt mithilfe der SELECT-CASE-Anweisung realisieren:

Das letzte Beispiel: DIM zahl AS INTEGER INPUT "Gib eine Zahl von 1 bis 3 ein: ", zahl IF zahl = 1 THEN PRINT "eins" ELSEIF zahl = 2 THEN PRINT "zwei" ELSEIF zahl = 3 THEN PRINT "drei" ELSE PRINT "die Zahl lag nicht zwischen 1 und 3!!" END IF

Jetzt das ganze mit Hilfe der SELECT-CASE-Anweisung realisiert DIM zahl AS INTEGER INPUT "Gib eine Zahl von 1 bis 3 ein: ", zahl SELECT CASE zahl CASE 1 PRINT "eins" CASE 2 PRINT "zwei" CASE 3 PRINT "drei" CASE ELSE PRINT "die Zahl lag nicht zwischen 1 und 3!!" END SELECT

Nun wollen wir uns an einem weiteren Beispiel die Möglichkeiten ansehen, wie die Ausdruckslisten aussehen können:

DIM zahl AS INTEGER
INPUT "Gib eine Zahl von 0 bis 10 ein: ", zahl

SELECT CASE zahl
   CASE 0, 1, 2, 3, 4    'Auflistung von Elementen
      PRINT "Die Zahl ist im Bereich von 0 bis 4"
   CASE 5 TO 10          'Bereich von Elementen
      PRINT "Die Zahl ist im Bereich von 5 bis 10."
   CASE IS > 10          'Vergleich mit einem Element
      PRINT "die Zahl ist größer als 10."
   CASE ELSE             'was übrig bleibt
      PRINT "die Zahl ist negativ"
END SELECT

Vergleichsoperatoren

Als erstes wollen wir uns überlegen, was Vergleichsoperatoren sind und wofür man sie einsetzt. Nun, Vergleichsoperatoren werden - wie der Name schon sagt - verwendet um zwei Ausdrücke miteinander zu vergleichen. In QuickBasic gibt es folgende Vergleichsoperatoren:

Übersicht:

Beschreibung	Symbol in QuickBasic	Smybol in der Mathematik
gleich	=	$=$
kleiner als	<	$<$
kleiner als oder gleich	<=	$\leq$
größer als	>	$>$
größer als oder gleich	>=	$\geq$
ungleich	<>	$\neq$

Jetzt wollen wir diese Operatoren aber auch anwenden. Erinnern wir uns kurz an das Kapitel über den IF-Block, dieser war folgendermaßen aufgebaut:

IF Bedingung THEN
   ...
END IF

Die Bedingung musste immer eine wahre Bedingung sein, allerdings haben wir bisher nur den Operator "=" verwendet. Selbstverständlich kann statt dem Gleichheitsoperator auch jeder andere Vergleichsoperator aus obiger Liste verwendet werden.

Ganz allgemein könnte man hier jetzt formulieren:

IF Ausdruck1 Vergleichsoperator Ausdruck2 THEN
   ...
END IF

Beispiel:

DIM zahl as INTEGER
INPUT "Gibt eine Zahl ein: ", zahl
IF zahl = 0 THEN
   PRINT "null"
ELSEIF zahl > 0 THEN
   PRINT "positive Zahl"
ELSEIF zahl < 0 THEN
   PRINT "negative Zahl"
END IF

logische Operatoren

Wie wir eben gesehen haben sind Vergleichsoperatoren sehr nützlich um z. B. die Richtigkeit von Benutzereingaben zu überprüfen. Darüber hinaus gibt es aber auch noch logische Operatoren. Diese werden verwendet um mehrere Bedingungen miteinander logisch zu verknüpfen.

Übersicht:

Beschreibung	Operator in QuickBasic	Logiksymbol
Negation / Logisches Komplement	NOT	$\neg$
Konjunktion (logisches "und")	AND	$\land$
Disjunktion (logisches "oder")	OR	$\lor$
Exklusives "oder"	XOR
Äquivalenz	EQV	$\Leftrightarrow$
Implikation	IMP	$\Rightarrow$

QuickBasic kennt alle der oben genannten Logikoperatoren. Für den Anfang sind eigentlich nur die drei oberen Operatoren interessant: NOT, AND und OR. In der praktischen Anwendung spielt der Operator NOT eine Sonderrolle. Der NOT-Operator interssiert sich nur für die folgende Aussage, während alle anderen Operatoren zwei Aussagen (die vorhergehende und die nachfolgende) miteinander verknüpfen.

NOT

Der NOT-Operator negiert die folgende Aussage. So wird aus NOT WahreAussage eine falsche Aussage.

Beispiel:

IF x = 0 THEN                     'Diese beiden Codezeilen
IF NOT (x <> 0) THEN              'sind identisch

AND

Mit dem AND-Operator lassen sich zwei Aussagen miteinander logisch UND verknüpfen, d. h. die gesamte Aussage ist nur dann wahr wenn die beiden miteinander verknüpften Aussagen wahr sind.

Beispiel:

IF zahl >= 1 AND zahl <= 10 THEN    'Der Code innerhalb dieses IF-Blocks wird nur dann ausgeführt,
   ...                              'wenn zahl im Bereich von 1 bis 10 liegt
END IF

OR

Bei einer OR-Verknüpfung wird das Reslutat genau dann wahr, wenn entweder der eine, oder der andere oder alle beide der getesteten Aussagen wahr sind.

Beispiel:

IF zahl < 1 OR zahl > 10 THEN      'Dieser Block wird nur ausgeführt wenn zahl
   ...                             'außerhalb der Bereichs 1 bis 10 liegt
END IF

Wahrheitstabelle

Diese Tabelle gibt die Ergebnisse einer durchgeführen Operation an. Die Buchstaben stehen für Wahre und Falsche Aussagen.

x1	x2	NOT x1	x1 AND x2	x1 OR x2	x1 XOR x2	x1 EQV x2	x1 IMP x2
F	F	W	F	F	F	W	W
F	W	W	F	W	W	F	F
W	F	F	F	W	W	F	W
W	W	F	W	W	F	W	W

Schleifen

Die Do-Loop-Schleife ist eine Schleife, die praktisch unendlich ausgeführt wird (daneben gibt es noch andere Schleifentypen, bei denen man festlegen kann, wann man sie abbricht). Sie kann beispielsweise verwendet werden, um auf das Eintreten eines bestimmtes Ereignisses zu warten, welches nicht so einfach als eine einzige Bedingung zu formulieren ist.

Syntax

 DO
     Anweisungen
     [ EXIT DO ]
     Anweisungen
 LOOP

Beispiel

Ein sehr sinnvolles Beispiel ist ein Programm, welches mit den Tasten gesteuert wird. Einigen Tasten werden bestimmte Funktionen zugewiesen. Üblicherweise läuft ein derartiges Programm endlos, bis der Benutzer es abbricht. Die Auswertung der gedrückten Tasten erfolgt mit INKEY$ und einer SELECT-Anweisung:

 REM Dieses Beispiel gibt unendlich lange die gedrückten Tasten auf dem Bildschirm aus.
 REM Es werden einige Beispiel-Tastencodes angegeben.
 REM Abbruch mit Escape.
 DO
     DO
         PRESSEDKEY$ = INKEY$
     LOOP UNTIL PRESSEDKEY$ <> ""
     
     SELECT CASE ASC(PRESSEDKEY$)
     CASE 13
         PRINT "Du hast die Eingabetaste gedrückt!"
     CASE 27
         PRINT "Du hast Escape gedrückt - das Programm wird beendet!"
         REM Da die Schleife der Hauptbestandteil des Programms ist, wird selbiges beendet, wenn die Schleife abgebrochen wird.
         EXIT DO
     CASE 48 TO 57
         PRINT "Du hast die Nummer"; ASC(PRESSEDKEY$) - 48; "gedrückt"
     CASE ELSE
         PRINT "Du hast das Zeichen "; PRESSEDKEY$; " mit dem Code"; ASC(PRESSEDKEY$); "gedrückt"
     END SELECT
 LOOP

Eine kurze Erklärung: Das ganze Programm "hängt" in einer Do-Loop-Schleife, die endlos läuft - bis eine Bedingung eintritt. In diesem Fall ist das das Registrieren des Tastendrucks mit dem Code 27 (dies ist die Escape-Taste). Der Tastendruck wird ausgewertet und entsprechend eine Zeile ausgegeben.

Bei den fortschrittlichen Themen befindet sich auch eine genauere Beschreibung zu der Funktion INKEY$.

Quick Basic: Loop-While Mit der Do-Loop-Until-Schleife kann etwas wiederholt ausgeführt werden, bis eine Variable einen bestimmten Wert hat.

Syntax

 DO
     Anweisungen
 LOOP UNTIL Variable = Wert

Beispiel

Ein sehr sinnvolles Beispiel ist ein Programm, welches mit den Tasten gesteuert wird. Einigen Tasten werden bestimmte Funktionen zugewiesen. Üblicherweise läuft ein derartiges Programm endlos, bis der Benutzer es abbricht. Die Auswertung der gedrückten Tasten erfolgt mit INKEY$:

 REM Dieses Beispiel wartet auf das Drücken der Escape-Taste.
 PRINT "Weiter mit Escape..."
 DO
     PRESSEDKEY$ = INKEY$
 LOOP UNTIL ASC(PRESSEDKEY$) = 27
 PRINT "Sie haben Escape gedrückt!"

Eine kurze Erklärung: Das ganze Programm "hängt" in einer Do-Loop-Schleife, die endlos läuft - bis eine Bedingung eintritt. In diesem Fall ist das das Registrieren des Tastendrucks mit dem Code 27 (dies ist die Escape-Taste). Der Tastendruck wird ausgewertet und die Schleife wird unterbrochen.

Bei den fortschrittlichen Themen befindet sich auch eine genauere Beschreibung zu der Funktion INKEY$.

Die While-Wend Schleife ist eine bedingte Schleife. Sie hat die gleiche Funktion wie die Do-Loop-While Schleife, ist aber für bedingte Wiederholungen sinnvoller.

Beispiel While-Wend:

   While x% < 100: x% = x% + 1
       Print x%
   Wend

Das selbe Beispiel mit einer Do-Schleife

   Do While x% < 100
       Print x%
       x% = x% + 1
   Loop

Grundlagen und Syntax

Bei einer FOR-Schleife wird ein Anweisungsblock eine bestimmte Anzahl mal ausgeführt.

Syntax:

 FOR Laufvariable = Untergrenze TO Obergrenze [ STEP Schrittweite ]
     Anweisungen
     [ EXIT FOR ]
     Anweisungen
 NEXT Laufvariable

Dabei wird eine Variable verändert:

 FOR x = 0 TO 5
     Anweisungen
 NEXT x

Hier würden die Anweisungen insgesamt 6x ausgeführt werden. Beim ersten Durchlauf würde die Variable x 0 sein, beim zweiten 1, beim dritten 2, beim vierten 3, beim fünften 4 und beim sechten 5. Man kann durch das optionale STEP-Schlüsselwort festlegen, in welchen Schritten sich die Zählervariable - hier x - verändern soll:

 FOR zaehler = 1 TO 7 STEP 2
     Anweisungen
 Next zaehler

Hier würde zaehler im ersten Durchlauf 1, im zweiten 3, im dritten 5 und im vierten 7 sein. Die Schrittweite kann auch Werte kleiner 1 annehmen oder negativ werden: Bei For c=2 to 0 step -1 nimmt c nacheinander die Werte 2, 1 und 0 an.

EXIT FOR-Anweisung

Mit der EXIT FOR-Anweisung ist es möglich eine FOR-NEXT-Schleife zu beenden.

FOR i = 1 TO 100
   IF i > 10 THEN EXIT FOR
   PRINT i
NEXT i

Dieses Beispiel wird nur die Zahlen von 1 bis 10 ausgeben. Beim 11. Durchlauf (wenn i = 11 ist) ist die Bedingung i > 10 erfüllt und die die EXIT FOR-Anweisung wird ausgeführt. Somit wird hier die FOR-Scheife verlassen.

Beispiele

Quadratzahlen

Im folgenden Programmbeispiel sollen die Quadratzahlen von 1 bis 5 berechnet werden. Hier wird zuerst eine Kopfzeile geschrieben, und darunter eine Liste der Zahlen 1, 2, 3, 4, 5 und den dazugehörigen Quadratzahlen 1, 4, 9, 16, 25.

  Dim i As Integer
  
  Print "Zahl", "Quadratzahl"    '''Kopfzeile''
  For i = 1 To 5
      Print i, i*i               '''Liste mit den Quadratzahlen erstellen''
  Next i

Primzahlen

Das nächste Beispiel soll zeigen, wie du mit Hilfe einer FOR-Schleife überprüfen kannst ob eine gegebene Zahl eine Primzahl ist. (zur Erinnerung: eine Primzahl ist eine Zahl, die nur durch eins und sich selbst teilbar ist.)

Idee: wenn n unsere Zahl ist wollen wir einfach der Reihe nach ausprobieren ob n durch alle Zahlen von 2 bis n-1 teilbar ist. n ist durch eine Zahl i (ohne Rest) teilbar, genau dann wenn n MOD i = 0 Und nun zu unserem kleinen Programm:

  DIM i AS INTEGER, n AS INTEGER, nichtPrim AS INTEGER
  
  n = 12                      'die Zahl die wir überprüfen wollen
  
  nichtPrim = 0               'hier wird gespeichert ob ein Teiler gefunden wurde
  FOR i = 2 TO n - 1
     IF n MOD i = 0 THEN      'wenn Teiler gefunden..
        nichtPrim = 1         '..merken und..
        EXIT FOR              '..Schleife verlassen
     END IF
  NEXT i
  
  IF nichtPrim = 0 THEN       'und zum Schluss wollen wir das Ergebnis auf dem Bildschirm ausgeben
     PRINT n, "ist eine Primzahl!"
  ELSE
     PRINT n, "ist KEINE Primzahl!! -  Gefundener Teiler:", i
  END IF

Primzahlen, Teil 2

Hier wollen wir den Code des vorigen Beispiels noch etwas optimieren.

Bekanntlich sind alle geraden Zahlen (2, 4, 6, etc.) durch 2 teilbar. Deshalb reicht es völlig aus die Teilbarkeit nur für ungerade Zahlen zu überprüfen.

Darüber hinaus ist der größte Teiler einer Zahl n maximal gleich der Wurzel aus n. Also reicht es als Obergrenze der Schleife die Wurzel aus n, also SQR(n) anzugeben.

  DIM i AS INTEGER, n AS INTEGER, nichtPrim AS INTEGER
  
  n = 377                        'die Zahl die wir überprüfen wollen
  
  IF n MOD 2 = 0 THEN            'Zahl ist durch 2 teilbar
     PRINT n, "ist durch 2 Teilbar."
  
  ELSE                           'falls nicht durch 2 teilbar
     nichtPrim = 0
     FOR i = 3 TO SQR(n) STEP 2  'neue Grenzen und Schrittweite
        IF n MOD i = 0 THEN
           nichtPrim = 1
           EXIT FOR
        END IF
     NEXT i
     
     IF nichtPrim = 0 THEN
        PRINT n, "ist eine Primzahl!"
     ELSE
        PRINT n, "ist KEINE Primzahl!! -  Gefundener Teiler:", i
     END IF
  END IF

Im Vergleich zur ersten Version ist unser neuer Algorithmus um einiges schneller als der vorherige, das liegt insbesondere daran, dass die Schleife wesentlich enger bei einanderliegende Grenzen hat und dass wir in größeren Schritten die Schleife durchlaufen.

Funktionen

Funktionen

Nun kommen wir zu einem weiteren, wichtigen Abschnitt im Buch: nämlich zu Funktionen. Eine Funktion ist ähnlich wie ein Unterprogramm. Sie kann bestimmte Aufgaben ausführen und natürlich auch Parameter übernehmen und verarbeiten. Der einzige Unterschied zwischen einer Sub und einer Funktion ist der, dass eine Funktion einen Wert zurückgibt. Dieser Rückgabewert kann von beliebigen Datentyp sein, also entweder eine Zahl oder eine Zeichenkette.

Syntax:

FUNCTION Name (Parameter1 AS Datentyp, Parameter2 AS Datentyp, ...)
   Anweisungen
   Name = Ausdruck
END FUNCTION

In der ersten Zeile wird die Funktion als solche bekannt gemacht, gefolgt vom Funktionsnamen. Der Name kann aus allen Buchstaben (a..z) und Zahlen (0..9) bestehen (Sonder- und Leerzeichen sind nicht erlaubt!). Damit wir den Rückgabetyp festlegen können, muss man am Ende des Funktionsnamens ein Variablensymbol schreiben (zum Beispiel $ für String). Nach der Definition der Funktion folgt die Parameterliste, welche beliebig viele Einträge enthalten kann. Die folgenden Zeilen enthalten alle Anweisungen, was die Funktion genau tun soll. In der letzten Zeile innerhalb des Funktionsblocks wird der Rückgabewert festgelegt. Name ist der Funktionsname und der Ausdruck ist der Rückgabewert. Am Schluss wird der Funktions-Block mit einem END FUNCTION abgeschlossen.

Sehen wir uns ein praktisches Beispiel an. Um eine neue Funktion anzulegen, führst du folgende Schritte aus:

• Klick auf das Menü Bearbeiten...
• Wähle den Menüpunkt Neue FUNCTION... aus
• Tipp nun den Namen der Funktion ein
• Klick auf OK

Bei QuickBASIC 4.5 muss man, um diese Menüpunkte zu erhalten, folgendes (einmalig) tun:

• Klick auf das Menü Optionen...
• Wähle Vollständiges Menü aus

Nun sehen wir zwei Zeilen am Bildschirm:

FUNCTION Name
END FUNCTION

Name ist der zuvor eingetippte Funktionsname. Setze den Cursor nun an das Ende der ersten Zeile und drücke die Eingabetaste. In der neuen Zeile wollen wir nun einen Rückgabe definieren. Tipp dazu folgende Zeile ein:

Name = 100

Ist dies geschehen, solltest du folgendes auf dem Bildschirm stehen haben:

FUNCTION Name
   Name = 100
END FUNCTION

Schalte nun zurück in das Hauptprogramm und tippe folgendes ein:

PRINT Name

Wenn wir das Programm nun ausführen, erhalten wir folgende Ausgabe:

100

Jetzt wollen wir aus der Funktion einen String machen. Schalte wieder zurück in das Funktionsfenster und füge ans Ende der ersten Zeile ein Dollarzeichen ($) ein. Nun müssen wir noch den Rückgabewert editieren. Ändere die Zeile

Name = 100

ab auf:

Name = "Hallo, ich bin die Funktion!"

Führen wir unser Programm aus, und wir werden als Ausgabe folgendes erhalten:

Hallo, ich bin die Funktion!

Nun wollen wir einen Parameter übergeben. Ändere die Funktion ab auf:

FUNCTION Name$ (Text AS STRING)
  Name = Text
END FUNCTION

Schalte ins Hauptprogramm zurück und ändere die PRINT-Zeile wie folgt ab:

PRINT Name("Ich bin ein Parameter.")

Als Ausgabe werden wir jetzt

Ich bin ein Parameter.

erhalten.

Stringbearbeitung

Mit Hilfe der Zeichenkettenfunktionen LEFT$ und RIGHT$ kannst du die ersten (links) und letzten (rechts) Zeichen aus einer Zeichenkette extrahieren.

Grundlagen, Syntax

Syntax:

 Ergebnis = LEFT$( Zeichenkette, Anzahl )
 Ergebnis = RIGHT$( Zeichenkette, Anzahl )

wobei Zeichenkette eine beliebige Zeichenkette und Anzahl die Anzahl der zurückzugebenden Zeichen darstellt.

Beispiel

PRINT LEFT$("Hallo", 2)               'gibt "Ha" aus
PRINT RIGHT$("datei.bas", 4)          'gibt ".bas" aus

Mid$ - Zeichen aus einer Zeichenkette extrahieren

Mit Mid$ ist es möglich, bestimmte Teile aus einer Zeichenkette zu extrahieren oder einen bestimmten Teil einer Zeichenkette zu bearbeiten.

Extrahieren einer Zeichenkette

Syntax

MID$(Zeichenkette, Anfangsposition, Anzahl_der_zu_extrahierenden_Zeichen)

MID$ gehört zu den Stringoperatoren und kann von einem beliebigen Punkt aus eine beliebige Anzahl an Zeichen ausgeben.

Beispiel

zeichenkette$ = "Ich bin eine Zeichenkette"
PRINT MID$(zeichenkette$, 5, 3) 'Erzeugt die Ausgabe: "bin"

Bearbeiten eines Zeichenkettenteils

Syntax

MID$(Zeichenkette_zum_Bearbeiten, Anfangsposition, Anzahl_der_zu_berarbeitenden_Zeichen) = Zeichenkette

Achtung: MID$ ersetzt nur so viele Zeichen, wie

• In der Anzahl_der_zu_berarbeitenden_Zeichen Variable angegeben sind
• die Zeichenkette lang ist, falls ihre Länge <= der der Anzahl_der_zu_berarbeitenden_Zeichen Variable ist

MID$ ändert nicht die Länge der Zeichenkette, etwa durch einfügen!

Beispiel

zeichenkette$ = "Das ist eine schwer zu verstehende Sache"
MID$(zeichenkette$, 14, 6) = "leicht"
PRINT zeichenkette$  'Ausgabe: "Das ist eine leicht zu verstehende Sache"

String in Zahl/Zahl in String umwandeln

In QuickBASIC ist das Rechnen mit Strings nicht möglich. 10 + "10" würde also nicht gehen. Es gibt jedoch zwei Befehle, mit dessen Hilfe man einen String in eine Zahl umwandeln kann oder umgekehrt. Die Befehle heißen VAL (String-zu-Zahl) und STR$ (Zahl-zu-String).

Die Syntax der beiden Befehle ist identisch:

VAL(Stringausdruck)
STR$(Zahl)

VAL erwartet einen Stringausdruck (zum Beispiel "Hallo") und STR$ eine ganze Zahl.

Beispiel:

DIM Text AS STRING 'Stringvariable initialisieren
DIM Zahl AS INTEGER 'Ganzzahlvariable initialisieren
DIM Summe AS INTEGER 'Ganzzahlvariable initialisieren
Text = "10" '10 als String
Zahl = 10 '10 als normale Zahl
Summe = VAL(Text) + Zahl 'Ergebnis von 10+10 speichern
PRINT Summe

Die ersten drei Zeilen deklarieren die notwendigen Variablen. In der vierten und fünften Zeile werden die Werte übergeben. Zeile sechs beinhaltet unseren neu gelernten Befehl VAL. In die Variable Summe wird die umgewandelte Zahl 10 mit der normalen Zahl 10 addiert. Die letzte Zeile gibt das Ergebnis auf dem Bildschirm aus.

Als Ausgabe würden wir folgendes erhalten:

20

Wenn wir nun die vorletzte Zeile abändern würden, wie hier:

Summe = Text + Zahl 'Ergebnis von 10+10 speichern

und das Programm starten, käme ein Fehler. Grund dafür: Eine Ganzzahlvariable kann keinen String aufnehmen.

String in Groß- bzw. Kleinbuchstaben umwandeln

Eine weitere Stringbearbeitungsfunktion ist das umwandeln in Groß- und Kleinbuchstaben. Es gibt hierfür zwei Funktionen: LCASE und UCASE - LowerCASE und UpperCASE.

Syntax:

UCASE$(Stringausdruck)
LCASE$(Stringausdruck)

Als Stringausdruck wird eine Zeichenfolge (zum Beispiel "Hallo") oder eine String-Variable erwartet.

Ein Beispiel zur Verdeutlichung:

Dim S As String 'Stringvariable initialisieren
S = "Hallo" 'Wert zuweisen
PRINT UCASE$(S) 'Großbuchstaben
PRINT LCASE$(S) 'Kleinbuchstaben

In der ersten Zeile deklarieren wir eine Variable des Typs String. Die nächste Zeile weist der neuen Variable den Text Hallo zu. Zum Schluss wird der String in Groß- und in Kleinbuchstaben ausgegeben.

Als Ausgabe würde man hier

HALLO
hallo

erhalten.

Man kann einen der beiden Befehle auch wie folgt nutzen:

Dim Antwort As String 'Antwort als Stringvariable initialisieren
INPUT "Ja oder Nein: ", Antwort 'Wert zuweisen
If UCASE$(Antwort) = "JA" Then 'Wenn Antwort ist Ja
   Print "Ja wurde eingegeben!"
End If

Die erste Zeile deklariert eine Stringvariable. In der zweiten wird der Benutzer aufgefordert Ja oder Nein einzutippen. In der dritten Zeile finden wir eine If-Bedingung. Wenn die Eingabe Ja ist (dabei ist es egal, ob die Antwort nun jA oder ja ist), wird eine Meldung ausgegeben. Die Bedingung ist immer dann wahr, wenn man Ja eingetippt hat. UCASE$ sorgt dafür, dass die Eingabe bei unterschiedlichen Schreibweisen immer großgeschrieben wird und somit der Bedingung entsprechen.

Alle führenden bzw. abschließende Leerzeichen entfernen

Meistens kommt es vor, dass ein String am Anfang und am Ende Leerzeichen besitzt. Meist tritt Ersteres bei der Ausgabe von Werten aus einer Variable auf. QuickBASIC besitzt zwei Befehle um diese Leerstellen zu entfernen: LTRIM$ (Leerzeichen am Anfang entfernen) und RTRIM$ (Leerzeichen am Ende entfernen).

Syntax:

LTRIM$(Stringausdruck)
RTRIM$(Stringausdruck)

Beide Funktionen benötigen einen String als Parameter, von dem sie die Leerzeichen entfernen.

Beispiel:

DIM Text AS STRING 'Stringvariable initialisieren
Text = " Hallo Welt"
PRINT Text 'Text mit Leerzeichen
PRINT LTRIM$(Text) 'Text ohne Leerzeichen

Die erste Zeile deklariert die Variable Text als String. In der zweiten Zeile wird der Text Hallo Welt mit einem Leerzeichen am Anfang in die Variable geschrieben. Am Schluss wird die Variable einmal mit und einmal ohne Leerzeichen ausgegeben.

Als Ausgabe würden wir folgendes erhalten:

 Hallo Welt
Hallo Welt

Zeichenkette in einem String suchen

Es kann sehr nützlich sein, wenn man einen Text in einem vorhandenen String suchen kann. QuickBASIC bietet auch für diesen Vorgang einen Befehl: INSTR. Mit dieser Funktion können wir abfragen, ob in einem String ein bestimmter Text vorhanden ist.

Syntax:

INSTR(Quellstring, Suchstring)

Der erste Stringausdruck ist die Quelle, also in welchem String wir suchen wollen. Im zweiten Stringausdruck wird angegeben, wonach wir suchen.

Beispiel:

 DIM Text AS STRING 'Stringvariable initialisieren
 Text = "QuickBASIC ist super!" 'Variable einen Wert zuweisen
 IF INSTR(Text, "QuickBASIC") THEN 'Abfragen ob Ausdruck vorhanden ist
    PRINT "Der Ausdruck ist vorhanden."
 END IF

Die erste Zeile deklariert eine Variable mit dem Typ String. In der nächsten Zeile übergeben der wir der eben deklarierten Variable einen Textausdruck (QuickBASIC ist super!). Nun kommt die Funktion INSTR ins Spiel: Als Quelle wird unsere Variable Text angegeben und als Suchstring der Ausdruck QuickBASIC. Da dieser Ausdruck vorhanden ist, ist die Bedingung wahr und wir erhalten eine Meldung auf den Bildschirm.

Als Ausgabe sehen wir also:

Der Ausdruck ist vorhanden.

Ändern wir nun die Wertübergabe wie folgt:

Text = "QUICKbasic ist super!"

Führe nun das Programm aus und wir werden merken, dass die Bedingung falsch ist. Grund: Der Befehl INSTR unterscheidet zwischen Groß- und Kleinschreibung. Somit ist der Ausdruck QuickBASIC ein völlig anderer als QUICKbasic.

Übungen

• Schreibe das Programm, welches einen beliebigen Text einliest, danach einen Suchstring verlangt und ausgibt, ob der Suchausdruck vorhanden ist oder nicht.
  • Das Programm soll nicht zwischen Groß-/Kleinschreibung unterscheiden (Tipp: UCASE$ und LCASE$)

Dateibearbeitung

Dateibearbeitung

Bis jetzt können wir Werte und Texte nur im Programm selber speichern. Das heißt, man hat diese Daten auch nur während des Programmbetriebs. Um Daten dennoch auf Dauer abzulegen, ist es sinnvoll, diese in eine Datei zu speichern. Praktisch wäre es auch noch, diese dann ins Programm wieder einlesen zu können. Speziell für die Datenbearbeitung bietet QuickBASIC zwei Befehle: OPEN (Um eine Datei für den Schreib- bzw. Lesezugriff zu öffnen) und CLOSE (Um eine Datei wieder zu schließen).

Sehen wir uns die Syntax an:

OPEN Dateiname FOR Zugriffsmodus AS Dateinummer
   'Datenspeicherung 
CLOSE Dateinummer

In der ersten Zeile sehen wir, dass der OPEN-Befehl mehrere Parameter braucht:

• Dateiname - Dies ist der Pfad zur Datei in Form eines Strings. Wenn man nur den Dateinamen angibt, wird die Datei in das Verzeichnis der Programm-EXE angelegt bzw. aus dieser wird gelesen. (ACHTUNG! Dateinamen und Verzeichnisse dürfen nicht mehr als acht Buchstaben haben!)
• Zugriffsmodus - Dieser Parameter beschreibt, ob wir etwas in die Datei schreiben oder aus der Datei lesen wollen. Hier eine Auflistung der wichtigsten Zugriffsmodi:
  • OUTPUT - Schreibt etwas in die Datei und überschreibt (falls vorhanden) den Inhalt der angegebenen Datei
  • INPUT - Liest Zeile für Zeile aus der Datei
  • APPEND - Schreibt etwas ans Ende der Datei (vorhandener Inhalt wird nicht gelöscht)
• Dateinummer - QuickBASIC benötigt für jeden Dateikanal eine eigene Nummer. Diese Nummer muss in diesem Format angegeben werden: #1, #2, usw.

In der letzten Zeile wird der Datenkanal wieder geschlossen und die Datei wird freigegeben. Innerhalb dieses Blockes muss man doch auch etwas machen können, oder?, wirst du dir wohl denken. Richtig, so ist es! Um mit Dateien interagieren zu können, benötigen wir zwei neue Befehle: PRINT Dateinummer und INPUT Dateinummer .

PRINT # und INPUT #

Syntax:

PRINT Dateinummer, Stringausdruck
INPUT Dateinummer, Stringausdruck

Dateinummer ist auch in diesen Befehlen im Format #1 anzulegen. Diese Nummer muss die vom anzusprechenden Datenkanal sein. Nach der Nummer folgt ein Komma und danach der String, der abgespeichert bzw. in dem eingelesen werden soll.

Es wird Zeit, für ein praktisches Beispiel:

DIM Text AS STRING 'Stringvariable initialisieren
Text = "Hallo Welt!"
OPEN "Test.txt" FOR OUTPUT AS #1 'Datenkanal öffnen für den Schreibzugriff mit der Nummer 1
   PRINT #1, Text 'Variableninhalt in Datei speichern
CLOSE #1 'Datenkanal schließen

Die erste Zeile deklariert eine Stringvariable und erhält in der zweiten den Text Hallo Welt!. Die dritte Zeile beinhaltet den Befehl, um die Datei für den Schreibzugriff (OUTPUT) zu öffnen. Als Dateinummer wird hier 1 verwendet. In der nächsten Zeile schreiben wir den Inhalt der zuvor deklarierten Stringvariabe in die Datei. Zum Abschluss wird der Datenkanal wieder geschlossen.

Wenn wir das Programm ausführen, werden wir in unserem QuickBASIC-Verzeichnis (es sei denn das Programm startet über eine kompilierte EXE) eine neue Datei finden, nämlich Test.txt. Diese Datei können wir im Editor öffnen und weiterbearbeiten. Solche einfach bearbeitbare Dateien nennt man auch sequentielle Dateien. Als Ausgabe erhalten wir in diesem Beispiel noch nichts, da wir erstmal nur etwas in eine Datei schreiben.

Sehen wir uns ein Beispiel zum Einlesen der eben gespeicherten Datei an:

 DIM Text AS STRING 'Stringvariabe initialisieren
 OPEN "Test.txt" FOR INPUT AS #1 'Dateikanal öffnen für den Lesezugriff mit der Nummer 1
    INPUT #1, Text 'erste Zeile in Variable speichern
 CLOSE #1 'Datenkanal schließen
 PRINT Text

Als erstes wird wieder eine Variable des Typs String deklariert. Danach wird der Datenkanal zum einlesen geöffnet und mit der Dateinummer 1 versehen. Als nächstes wird die erste Zeile in der Datei, im vorigen Beispiel also Hallo Welt!, in die Variable Text gespeichert. Der Datenkanal wird wieder geschlossen und zu guter Letzt wird der eben eingelesene Text am Bildschirm ausgegeben. Die Ausgabe sähe dann so aus:

 Hallo Welt!

Nun sehen wir uns APPEND näher an.

Dazu ein neues Beispiel:

DIM Text AS STRING 'Stringvariable initialisieren
Text = "Und noch einmal..."
OPEN "Test.txt" FOR APPEND AS #1 'Dateikanal öffnen für den Schreibzugriff mit der Nummer 1
   PRINT #1, Text 'Variableninhalt an Datei anhängen
CLOSE #1 'Datenkanal schließen

Die erste Zeile deklariert wieder eine Stringvariable, die zweite legt einen Text in dieser fest (Und noch einmal...). Danach wird der Datenkanal geöffnet für den Schreibzugriff (versehen mit der Nummer 1) und der Variableninhalt in die Datei gespeichert. Am Schluss wird der Datenkanal geschlossen. Eine Ausgabe auf dem Bildschirm erfolgt nicht.

Wenn wir nun die Datei Test.txt öffnen, werden wir feststellen, dass wir nun zwei Zeilen in der Datei haben:

Hallo Welt!
Und noch einmal...

EOF

Zum Schluss möchte ich noch eine weitere, nette Funktion von QuickBASIC erwähnen: EOF (ausgeschrieben End Of File). Mit dieser Funktion können wir prüfen, ob das Dateiende erreicht ist und können uns so eine Fehlermeldung ersparen.

Syntax:

EOF(Dateinummer)

Die Dateinummer ist die Nummer des zu prüfenden Datenkanals und muss im Format #1, #2, usw. vorliegen. Wir wollen unser kleines Einlesebeispiel etwas abwandeln:

 DIM Text AS STRING 'Stringvariabe initialisieren
 OPEN "Test.txt" FOR INPUT AS #1 'Dateikanal öffnen für den Lesezugriff mit der Nummer 1
    DO WHILE NOT EOF(1) 'Schleife solange durchlaufen lassen, bis EOF erreicht
       INPUT #1, Text 'Zeile in Variable speichern
       PRINT Text 
    LOOP
 CLOSE #1 'Datenkanal schließen

Die erste Zeile deklariert eine Variable des Typs String. Danach wird der Datenkanal für den Lesezugriff mit der Nummer 1 geöffnet. Nun kommt eine Schleife: es wird solange eine Zeile der Datei eingelesen und ausgegeben, bis das Ende von dieser erreicht ist. Somit ist es möglich Dateien mit unbekannter Länge zu lesen. Am Ende wird der Datenkanal wieder geschlossen.

Übungen

• Schreibe ein Programm, welches den Namen eines Freundes einliest, ihn in einer Datei speichert und danach wieder ausgibt.

• Schreibe ein Programm, welches die Zahlen 1-10 in eine Datei schreibt, und danach wieder ausgibt.

• Schreibe ein Programm, welches deine derzeitigen (oder deine letzten) Klassenkameraden abspeichert.

Grafikfunktionen

Mit QuickBASIC ist es auch möglich, Grafiken aus dem Bildschirm auszugeben. Die Rede ist dabei zwar nicht von unendlich hohen Auflösungen und 16 Millionen Farben, aber immerhin 640 mal 480 Pixel und 16 Farben - damit lässt sich schon einiges anstellen. Anspruchsvollere Benutzeroberflächen durch Rahmenelemente und vieles mehr sind damit zu realisieren.

WICHTIG: Diese Funktionen funktionieren nicht, wenn man QuickBASIC in einer Kommandobox unter Windows ausführt! Man braucht dazu entweder ein reines DOS-System oder einen Emulator, wie beispielsweise DOSbox (läuft unter anderem unter Linux und Windows). Auf die Installation dieses Programms wird hier aber nicht näher eingegangen. Wenn hier von einem Auflösungswechsel die Rede ist, ist damit entweder der Vollbildmodus einer DOSbox gemeint, oder es bezieht sich auf die Ausführung unter einem echten DOS-System. In einer DOSbox wird sich stattdessen die Fenstergröße ändern.

Vorbereitungen

Bevor wir aber anfangen können, wild die Kontrolle über knapp 300.000 Bildpunkte zu übernehmen, müssen wir uns noch mit einer lästigen Auswahl herumschlagen: der Auswahl eines Grafikbildschirms. Auf den Standardbildschirm mit der Nummer 0 kann man nämlich nichts zeichnen. Es gibt dann einige andere Bildschirme, wovon jener mit der Nummer 12 am praktischten ist: Er steht für den VGA-Modus, also 640 mal 480 Pixel mit je 16 möglichen Farben. Setzen wir also an den Anfang des Programms diese Anweisung, um den Bildschirm umzuschalten:

SCREEN 12

Und das war es auch schon - für die Programmausführung wird die Bildschirmauflösung geändert und man hat Zugriff auf die Grafikfunktionen.

Linien zeichnen mit LINE

Es wäre ziemlich lästig, mit PSET ein paar tausend Bildpunkte einzeln zu setzen, und leicht wartbar ist es allemal nicht, geschweige denn übersichtlich. Da diese Funktion wohl auch kaum einer benötigt, wird auf sie nicht eingegangen. Wenden wir uns lieber einer interessanteren Funktion zu, nämlich jener zum Zeichnen von Linien und Rechtecken. Die Syntax ist wie folgt:

Syntax

LINE [[STEP](x1, y1)] - [STEP](x2, y2)[, [color][, [B[F]][, style]]]

Das Schlüsselwort STEP bedeutet, dass die Koordinaten relativ zu der letzten Cursorposition sind, oder (wenn es beim zweiten Mal angegeben wird) relativ zur ersten Koordinate. Die Angabe des ersten Koordinatenblocks ist optional, dann wird die Linie von der Cursorposition gezeichnet. Als color kann mein eine der 16 Farbnummern einsetzen.

Wird B angegeben (ebenfalls eine Art Schlüsselwort), so wird ein Rechteck gezeichnet. Folgt diesem B ein F, wird der Inhalt des Rechtecks auch noch ausgefüllt.

Beispiel

Alles in allem also schon ziemlich viel - es folgt ein Beispiel.

 REM Den Bildschirm wechseln.
 SCREEN 12
 
 REM Eine weiße Linie zeichnen von 50,50 zu 150,150 (relative Angaben!)
 LINE (50, 50)-STEP(100, 100), 15
 
 REM Ein rotes Rechteck irgendwo in der oberen rechten Ecke. (ACHTUNG: Die
 REM Angaben reichen von 0,0 bis 639,479, darum ist letzteres die obere
 REM rechte Bildschirmecke.)
 LINE (539, 0)-(639, 100), 12, B
 
 REM Davon überlappt wird nun ein gelbes Rechteck entstehen.
 LINE STEP(-150, -50)-STEP(75, 75), 14, BF

Kreise zeichnen mit CIRCLE

Mit CIRCLE kann man dann auch noch Kreise zeichnen. DIe Syntax ist wie folgt:

Syntax

CIRCLE [STEP](x, y), radius[, [color][, [start][, [end][, aspect]]]]

Mit STEP kann man auch hier wieder den Gebrauch von relativen Koordinaten anschalten. x und y bezeichnen den Kreismittelpunkt, radius den Radius. color bezeichnet auch hier wieder eine Farbe.

Wenn nur Kreissegmente gezeichnet werden sollen, dann sind die Parameter start und end zu gebrauchen: sie geben die Winkel an, von denen gezeichnet wird. Dieser ist in Radiant angegeben, wer also seinen Winkel wie gewohnt in Grad angeben will, muss seinen Winkel mit pi multiplizieren und durch 180 teilen.

Beispiel

 SCREEN 12
 
 REM Zuerst einen einfachen Kreis in der Mitte...
 CIRCLE STEP(0, 0), 100, 15
 
 REM ...dann ein Kreisabschnitt. (WICHTIG: Umrechnung von Grad nach Rad!)
 CIRCLE STEP(0, 0), 150, 14, 0 * 3.141592 / 180, 90 * 3.141592 / 180
 
 REM Und schließlich eine Ellipse, die in der Horizontalen gestreckt ist:
 CIRCLE (320, 240), 200, 12, , , .5

Soundfunktionen

Hinweis:
Die Aufgelisteten Befehle erzeugen Sounds aus dem Systemlautsprecher. Es kann vorkommen, das in neueren Rechnern keine vorhanden sind. Das bedeutet, dass die Sounds nicht gehört werden können.

Es gibt einige Funktionen in QuickBasic, um Sounds zu erzeugen:

BEEP

Die einfachste Methode, einen Ton zu erzeugen, ist der Befehl BEEP. Vielleicht erinnerst du dich: Wir haben bei der Passwortabfrage bei der Do-While-Schleife schon einmal davon Gebrauch gemacht.

Beispiel

BEEP

Probier es einfach mal im Compiler aus. Wenn du den Befehl ausführst, hörst du einen schrillen Piep-Ton aus dem Inneren des Rechners. Ehrlich gesagt kann ich diese Methode nur für Fehlermeldungen empfehlen. Wenn man den Ton 4x hintereinander hört, kann das einem ganz schön auf die Nerven gehen.

PLAY

Diese Methode erzeugt ziemlich einfach viele verschiedene Töne. Man kann damit sogar Lieder komponieren.

Aufbau

PLAY "Befehlsstring"

Beispiel

PLAY "C4 D E16 F G"

Dieser Befehl spielt die Tonleiter C, D, E, F und G, wobei die Note C eine Viertelnote und die Note E eine 16er-Note ist. Es ist also sehr einfach, mit Quick Basic Musik zu komponieren.

Der Zeichenstring

Folgende Zeichen können im Zeichenstring verwendet werden:

• C,D,E,F,G,A Stehen für die Tonleiter
• Mit < spielt man eine Oktave höher, mit > eine Oktave tiefer,
• Ein Punkt verlängert eine Note(Punktierte Note)

SOUND

Der Befehl SOUND ist eine recht komplizierte Angelegenheit, um einen Ton zu erzeugen.

Aufbau

SOUND Frequenz, Dauer

Beispiel

SOUND 500, 18.2

Dieses Beispiel erzeugt einen Ton mit einer Frequenz von 500 Hertz und einer Dauer von 18.2 Systemtakten, was einer Sekunde entspricht. Wie man sieht, eignet sich SOUND weniger, um ein Lied abzuspielen. Man kann aber damit extrem hohe Töne erzeugen. Mit diesem Beispiel erzeugt man einen Ultraschall-Ton(den man als Mensch nicht hören kann):

SOUND 19999, 18.2

Hinweis

Der Frequenzton muss zwischen 37 und 32767 liegen. Außerdem sollte man darauf achten, dass Kommas bei der Dauer nur mit einem Punkt geschrieben werden sollen.

Mathematische Funktionen

interne mathematische Funktionen

Da QuickBasic über viele mathematische Funktionen verfügt, ist es auch für Anwendungen aus der numerischen Mathematik gut geeignet. In diesem Kapitel sollen die mathematischen Funktionen, die QuickBasic kennt vorgestellt werden.

Hier eine Übersicht aller Funktionen:

Funktion in QuickBasic	mathematische Funktion	Beschreibung
SGN(x)	$f(x)=\operatorname {sgn}(x):={\begin{cases}\;\;\,1&\;x>0\\\;\;\,0&\;x=0\\-1&\;x<0\\\end{cases}}$	Die Signum-Funktion liefert das Vorzeichen von $x$, d. h. SGN(x) = 1, wenn $x$ positiv, SGN(x) = -1, wenn $x$ negativ und SGN(x) = 0, wenn $x=0$
ABS(x)	$f(x)=|x|$	liefert den Betrag von $x$. (das Vorzeichen von $x$ wird einfach 'abgeschnitten'.
INT(x)		Rundet $x$ auf die nächste ganze Zahl ab.
SIN(x)	$f(x)=\sin x$	liefert den Sinus von $x$. Der Winkel $x$ muss im Bogenmaß angegeben werden. x kann ein von einem beliebigen numerischen Datentyp sein. Der Rückgabewert ist vom Typ SINGLE, es sei dann x wurde als DOUBLE angegeben, dann ist auch der Rückgabewert vom Typ DOUBLE.
COS(x)	$f(x)=\cos x$	liefert den Kosinus von $x$. Der Winkel $x$ muss im Bogenmaß angegeben werden. x kann ein von einem beliebigen numerischen Datentyp sein. Der Rückgabewert ist vom Typ SINGLE, es sei dann x wurde als DOUBLE angegeben, dann ist auch der Rückgabewert vom Typ DOUBLE.
TAN(x)	$f(x)=\tan x$	liefert den Tangens von $x$. Der Winkel $x$ muss im Bogenmaß angegeben werden. x kann ein von einem beliebigen numerischen Datentyp sein. Der Rückgabewert ist vom Typ SINGLE, es sei dann x wurde als DOUBLE angegeben, dann ist auch der Rückgabewert vom Typ DOUBLE.
ATN(x)	$f(x)=\arctan x$	liefert den Arkustangens von $x$. Der Rückgabewert stellt einen Winkel im Bogenmaß dar. x kann ein von einem beliebigen numerischen Datentyp sein. Der Rückgabewert ist vom Typ SINGLE, es sei dann x wurde als DOUBLE angegeben, dann ist auch der Rückgabewert vom Typ DOUBLE.
EXP(x)	$f(x)=e^{x}$	gibt $e$ (die Basis des natürlichen Logarithmus) potenziert mit $x$ zurück. Der Exponent $x$ darf nicht größer als $88{,}02969$ sein, andernfalls wird ein Fehler gemeldet. x kann ein von einem beliebigen numerischen Datentyp sein. Der Rückgabewert ist vom Typ SINGLE, es sei dann x wurde als DOUBLE angegeben, dann ist auch der Rückgabewert vom Typ DOUBLE.
LOG(x)	$f(x)=\ln x$	liefert den natürlichen Logarithmus, also den Logarithmus zu Basis $e$ von $x$. $x$ muss echt größer als Null sein, andernfalls wird ein Fehler gemeldet. x kann ein von einem beliebigen numerischen Datentyp sein. Der Rückgabewert ist vom Typ SINGLE, es sei dann x wurde als DOUBLE angegeben, dann ist auch der Rückgabewert vom Typ DOUBLE.
SQR(x)	$f(x)={\sqrt {x}}$	liefert die Quadratwurzel aus $x$. $x$ muss größer oder gleich Null sein, andernfalls wird ein Fehler gemeldet. x kann ein von einem beliebigen numerischen Datentyp sein. Der Rückgabewert ist vom Typ SINGLE, es sei dann x wurde als DOUBLE angegeben, dann ist auch der Rückgabewert vom Typ DOUBLE.

weitere mathematische Funktionen

Über mathematische Zusammenhänge - auf die hier nicht näher eingegangen werden soll - kann der Funktionsumfang von QuickBasic noch erweitert werden. Es ist alledings zu beachten, dass nicht alle Funktionen auch für alle Zahlen definiert sind, daher ist jeweils auf den Definitionsbereich zu achten, da sonst Leufzeitfehler auftreten könnten.

Hier eine Übersicht weiterer Funktionen, und wie sie in QuickBasic realisiert werden können:

Funktion	mathematischer Zusammenhang	Realisierung in QuickBasic
n-te Wurzel	${\sqrt[{n}]{x}}=x^{\frac {1}{n}}$	sqrtn(x, n) = x ^ (1 / n)
Logarithmus zur Basis a	$\log _{a}x={\frac {\ln x}{\ln a}}$	loga(x, a) = LOG(x) / LOG(a)

Trigonometrische Funktionen

Funktion	mathematischer Zusammenhang	Realisierung in QuickBasic
Kotangens	$\cot x={\frac {1}{\tan x}}$	cot(x) = 1 / TAN(x)
Sekans	$\sec x={\frac {1}{\cos x}}$	sec(x) = 1 / COS(x)
Kosekans	$\csc x={\frac {1}{\sin x}}$	csc(x) = 1 / SIN(x)
Arkussinus	$\arcsin x=\arctan {\frac {x}{\sqrt {1-x^{2}}}}$	arcsin(x) = ATN(x / SQR(1 - x * x))
Arkuskosinus	$\arccos x=-\arctan {\frac {x}{\sqrt {1-x^{2}}}}+{\frac {\pi }{2}}$	pi# = 3.14159265358979 arccos(x) = -ATN(x / SQR(1 - x * x)) + pi# / 2
Arkuskotangens	$\operatorname {arccot} x=-\arctan x+{\frac {\pi }{2}}$	pi# = 3.14159265358979 arccot(x) = -ATN(x) + pi# / 2

Hyperbolische Funktionen

Funktion	mathematischer Zusammenhang	Realisierung in QuickBasic
Sinus Hyperbolicus	$\sinh x={\frac {e^{x}-e^{-x}}{2}}$	sinh(x) = (EXP(x) - EXP(-x)) / 2
Kosinus Hyperbolicus	$\cosh x={\frac {e^{x}+e^{-x}}{2}}$	cosh(x) = (EXP(x) + EXP(-x)) / 2
Tangens Hyperbolicus	$\tanh x={\frac {2}{e^{-2x}+1}}+1$	tanh(x) = 2 / (EXP(-2 * x) + 1) + 1
Kotangens Hyperbolicus	$\coth x={\frac {e^{2x}+1}{e^{2x}-1}}$	coth(x) = (EXP(2 * x) + 1) / (EXP(2 * x) - 1)
Sekans Hyperbolicus	$\operatorname {sech} x={\frac {2}{e^{x}+e^{-x}}}$	sech(x) = 2 / (EXP(x) + EXP(-x))
Kosekans Hyperbolicus	$\operatorname {csch} x={\frac {2}{e^{x}-e^{-x}}}$	csch(x) = 2 / (EXP(x) - EXP(-x))
Areasinus Hyperbolicus	$\operatorname {arsinh} x=\ln \left(x+{\sqrt {x^{2}+1}}\right)$	arsinh(x) = LOG(x + SQR(x * x + 1))
Areakosinus Hyperbolicus	$\operatorname {arcosh} x=\ln \left(x+{\sqrt {x^{2}-1}}\right)$	arcosh(x) = LOG(x + SQR(x * x - 1))
Areatangens Hyperbolicus	$\operatorname {artanh} x={\frac {1}{2}}\ln {\frac {1+x}{1-x}}$	artanh(x) = LOG((1 + x) / (1 - x)) / 2
Areakotangens Hyperbolicus	$\operatorname {arcoth} x={\frac {1}{2}}\ln {\frac {x+1}{x-1}}$	arcoth(x) = LOG((x + 1) / (x - 1)) / 2
Areasekans Hyperbolicus	$\operatorname {arsech} x=\ln {\frac {1+{\sqrt {1-x^{2}}}}{x}}$	arsech(x) = LOG((1 + SQR(1 - x * x)) / x)
Areakosekans Hyperbolicus	$\operatorname {arcsch} x=\ln \left({\frac {1}{x}}+{\sqrt {1+{\frac {1}{x^{2}}}}}\right)$	arcsch(x) = LOG(1 / x + SQR(1 + 1 / x / x))

Anhang

Liste der QuickBasic-Schlüsselwörter:

Inhaltsverzeichnis A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

A

• ABS-Funktion
• ACCESS
• ALIAS
• AND Operator
• ANY
• APPEND
• AS
• ASC-Funktion
• ATN-Funktion

B

• BASE
• BASIC Programmzeilen
• BEEP-Anweisung
• BINARY
• BLOAD-Anweisung
• BSAVE-Anweisung
• BYVAL

C

• CALL-Anweisung
• CALLS-Anweisung
• CALL ABSOLUTE-Anweisung
• CALL INTERRUPT-Anweisung
• CASE
• CDBL-Funktion
• CDECL
• CHAIN-Anweisung
• CHDIR-Anweisung
• CHR$-Funktion
• CINT-Funktion
• CIRCLE-Anweisung
• CLEAR-Anweisung
• CLNG-Funktion
• CLOSE-Anweisung
• CLS-Anweisung
• COLOR-Anweisung
• COM-Anweisung
• COMMAND$-Funktion
• COMMON-Anweisung
• CONST-Anweisung
• COS-Funktion
• CSNG-Funktion
• CSRLIN-Funktion
• CVD-Funktion
• CVDMBF-Funktion
• CVI-Funktion
• CVL-Funktion
• CVS-Funktion
• CVSMBF-Funktion

D

• DATA-Anweisung
• Datentypen
• DATE$-Funktion
• DATE$-Anweisung
• DECLARE-Anweisung (BASIC)
• DECLARE-Anweisung (Nicht-BASIC)
• DEF FN-Anweisung
• DEF SEG-Anweisung
• DEFDBL-Anweisung
• DEFINT-Anweisung
• DEFLNG-Anweisung
• DEFSNG-Anweisung
• DEFSTR-Anweisung
• DIM-Anweisung
• DO...LOOP-Anweisung
• DOUBLE
• DRAW-Anweisung
• $DYNAMIC-Metabefehl

E

• ELSE
• ELSEIF
• END-Anweisung
• END IF
• ENVIRON-Anweisung
• ENVIRON$-Funktion
• EOF-Funktion
• EQV Operator
• ERDEV-Funktion
• ERDEV$-Funktion
• ERL-Funktion
• ERR-Funktion
• ERROR-Anweisung
• EXIT-Anweisung
• EXP-Funktion
• ERASE-Anweisung

F

• FIELD-Anweisung
• FILEATTR-Funktion
• FILES-Anweisung
• FIX-Funktion
• FOR...NEXT-Anweisung
• FRE-Funktion
• FREEFILE-Funktion
• FUNCTION-Anweisung

G

• GET-Anweisung (Datei E/A)
• GET-Anweisung (Graphik)
• GOSUB-Anweisung
• GOTO-Anweisung

H

• HEX$-Funktion

I

• IF...THEN-Anweisung
• IMP Operator
• $INCLUDE-Metabefehl
• INKEY$-Funktion
• INP-Funktion
• INPUT-Anweisung
• INPUT #-Anweisung
• INPUT$-Funktion
• INSTR-Funktion
• INT-Funktion
• INTEGER
• IOCTL-Anweisung
• IOCTL$-Funktion
• IS

K

• KEY-Anweisung
• KEY(n)-Anweisung
• KILL-Anweisung

L

• LBOUND-Funktion
• LCASE$-Funktion
• LEFT$-Funktion
• LEN-Funktion
• LET-Anweisung
• LINE-Anweisung (Graphik)
• LINE INPUT-Anweisung
• LINE INPUT #-Anweisung
• LIST
• LOC-Funktion
• LOCAL
• LOCATE-Anweisung
• LOCK...UNLOCK-Anweisungen
• LOF-Funktion
• LOG-Funktion
• LONG
• LOOP
• LPOS-Funktion
• LPRINT-Anweisung
• LSET-Anweisung
• LTRIM$-Funktion

M

• MID$-Funktion
• MID$-Anweisung
• MKD$-Funktion
• MKDIR-Anweisung
• MKDMBF$-Funktion
• MKI$-Funktion
• MKL$-Funktion
• MKS$-Funktion
• MKSMBF$-Funktion
• MOD
• Module und Prozeduren

N

• NAME-Anweisung
• NEXT
• NOT Operator

O

• OCT$-Funktion
• OFF
• ON
• ON COM(n)-Anweisung
• ON ERROR-Anweisung
• ON Ereignis-Anweisungen
• ON KEY(n)-Anweisung
• ON PEN-Anweisung
• ON PLAY(n)-Anweisung
• ON STRIG(n)-Anweisung
• ON TIMER(n)-Anweisung
• ON UEVENT-Anweisung
• ON...GOSUB-Anweisung
• ON...GOTO-Anweisung
• OPEN-Anweisung (Datei E/A)
• OPEN COM-Anweisung
• OPTION BASE-Anweisung
• OR Operator
• OUT-Anweisung
• OUTPUT

P

• PAINT-Anweisung
• PALETTE-Anweisungen
• PCOPY-Anweisung
• PEEK-Funktion
• PEN-Funktion
• PEN-Anweisung
• PLAY(n)-Funktion
• PLAY-Anweisung (Musik)
• PLAY-Anweisung (Ereignisverfolgung)
• PMAP-Funktion
• POINT-Funktion
• POKE-Anweisung
• POS-Funktion
• PRESET-Anweisung
• PRINT-Anweisung
• PRINT USING-Anweisung
• PRINT #-Anweisung
• PSET-Anweisung
• PUT-Anweisung (Graphik)
• PUT-Anweisung (Datei E/A)

R

• RANDOM
• RANDOMIZE-Anweisung
• READ-Anweisung
• REDIM-Anweisung
• REM-Anweisung
• RESET-Anweisung
• RESTORE-Anweisung
• RESUME-Anweisung
• RETURN-Anweisung
• RIGHT$-Funktion
• RMDIR-Anweisung
• RND-Funktion
• RSET-Anweisung
• RTRIM$-Funktion
• RUN-Anweisung

S

• SADD-Funktion
• SCREEN-Funktion
• SCREEN-Anweisung
• SEEK-Funktion
• SEEK-Anweisung
• SELECT CASE-Anweisung
• SETMEM-Funktion
• SGN-Funktion
• SHARED-Anweisung
• SHELL-Anweisung
• SIGNAL
• SIN-Funktion
• SINGLE
• SLEEP-Anweisung
• SOUND-Anweisung
• SPACE$-Funktion
• SPC-Funktion
• SQR-Funktion
• STATIC-Anweisung
• $STATIC-Metabefehl
• STEP
• STICK-Funktion
• STOP-Anweisung
• STR$-Funktion
• STRIG-Funktion
• STRIG-Anweisung
• STRING
• STRING$-Funktion
• SUB-Anweisung
• SWAP-Anweisung
• SYSTEM-Anweisung

T

• TAB-Funktion
• TAN-Funktion
• THEN
• TIME$-Funktion
• TIME$-Anweisung
• TIMER-Funktion
• TIMER-Anweisung
• TO
• TROFF-Anweisung
• TRON-Anweisung
• TYPE-Anweisung

U

• UBOUND-Funktion
• UCASE$-Funktion
• UEVENT-Anweisung
• UNLOCK-Anweisung
• UNTIL
• USING

V

• VAL-Funktion
• VARPTR-Funktion
• VARPTR$-Funktion
• VARSEG-Funktion
• VIEW-Anweisung (Graphik)
• VIEW-Anweisung (Text)

W

• WAIT-Anweisung
• Wahrheitstabelle logische Operatoren
• WEND
• WHILE...WEND-Anweisung
• WIDTH-Anweisungen
• WINDOW-Anweisung
• WRITE-Anweisung (Bildschirm E/A)
• WRITE-Anweisung (Datei E/A)

X

• XOR Operator