visual basic - · pdf filevisual basic 6.0 bei. zitat aus der readme-datei: das verzeichnis...

$: Visual Basic - · PDF fileVisual Basic 6.0 bei. Zitat aus der Readme-Datei: Das Verzeichnis \VB6 enthält die Ablaufmodell-Edition von Visual Basic 6. Diese Visual Basic$
www.KnowWare.de

Visual Basicfür Einsteiger

Peter Hatje

Kn

ow

Wa

reS

pe

cia

l!E

infa

ch

&v

ers

tän

dli

ch

KnowWareSpecial!Free!

Acrobat Reader - Bestellung - Autoren gesucht

Acrobat Reader: Wie ...F5/F6 öffnet/schließt die Ansicht Lesezeichen

Strg+F sucht

Im Menü Ansicht stellst du ein, wie die Datei gezeigt wird

STRG+0 = Ganze Seite STRG+1 = Originalgrösse STRG+2 = Fensterbreite

Im selben Menü kannst du folgendes einstellen:: Einzelne Seite,Fortlaufend oder Fortlaufend - Doppelseiten .. Probiere es aus, umdie Unterschiede zu sehen.

Navigation

Pfeil Links/Rechts: eine Seite vor/zurück

Alt+ Pfeil Links/Rechts: Wie im Browser: Vorwärts/ZurückStrg++ vergrößert und Strg+– verkleinert

Bestellung und Vertrieb für den BuchhandelBonner Pressevertrieb, Postfach 3920, D-49029 OsnabrückTel.: +49 (0)541 33145-20Fax: +49 (0)541 [email protected]/bestellen

Autoren gesuchtDer KnowWare-Verlag sucht ständig neue Autoren. Hast du ein Thema,daß dir unter den Fingern brennt? - ein Thema, das du anderen Leutenleicht verständlich erklären kannst?Schicke uns einfach ein paar Beispielseiten und ein vorläufigesInhaltsverzeichnis an folgende Adresse:[email protected] werden uns deinen Vorschlag ansehen und dir so schnell wiemöglich eine Antwort senden.

www.knowware.de

Inhalt

Visual Basic für Einsteiger - 02-09-13

3

Vorbemerkung...................................................4Das Programm...................................................5

Erwerb ............................................................5Installation......................................................5

Starten ................................................................6Einrichten..........................................................6Beschreibung ....................................................7

Projekt-Fenster ...............................................7Eigenschaften-Fenster ....................................7Werkzeug-Fenster ..........................................8Form-Fenster ..................................................8

Basic..................................................................10Code................................................................10Variablen.........................................................10

Variablen deklarieren ...................................11Geltungsbereich............................................11Variablenwerte .............................................11

Konstanten ......................................................11Operatoren ......................................................12

Standardoperatoren ......................................12Vergleichsoperatoren ...................................12Logische Operatoren ....................................12

Funktionen ......................................................13Numerische Funktionen ...............................13Zeichenkettenfunktionen..............................13

Visual Basic ......................................................14Eigenschaften ...............................................14Ereignisse .....................................................14Methoden .....................................................14Prozeduren....................................................15Funktionen ...................................................15

Das erste Programm........................................16Bedienoberfläche..........................................16Zufall ............................................................20

Programmcode................................................21Schaltflächen für den Tipp ...........................21Die Zufallszahl des Computers ....................22Die Prozedur Auswertung anlegen...............22Die Anzeige der Augenzahl .........................23Prozedur Würfelanzeige anlegen .................25Mitteilungsfenster (Messagebox) .................26

Kontrollstrukturen...........................................28GOTO...........................................................28

Entscheidungen...............................................29If-Strukturen.................................................29Select/Case-Struktur.....................................29

Schleifen .........................................................30For-Next-Schleife.........................................30While-Wend-Schleifen.................................30Do-Loop-Schleifen.......................................31

Dateiverwaltung .............................................. 32Datei lesen.................................................... 32

Datei speichern ............................................... 32Zweites Programmprojekt ............................. 33

Oberfläche.................................................... 33Code ............................................................. 35

Grafik ............................................................... 41Grundlagen ..................................................... 41

Methoden ..................................................... 41Eigenschaften............................................... 41

Simulationen .................................................... 52Epidemie im Aquarium................................ 52Grundannahmen........................................... 52Code ............................................................. 52

Anhang ............................................................. 55Suffixe für Steuerelemente........................... 55Text mit Zeichenketten-Funktionen

umkehren ................................................... 55Funktion ....................................................... 55Zeichenkette umkehren mit Funktion .......... 56Eingabe-Dialogfeld (Input-Box) .................. 57

Vorbemerkung


4

VorbemerkungDu hast dich entschieden, eigene Programmeschreiben zu wollen? Ich finde das gut. Dubefindest dich damit in einer guten Tradition,denn es ist noch nicht allzu lange her (allerdingsbei dem Tempo, dass die Computerentwicklungvorlegt, sind es Jahrhunderte), dass Amateure –und da vornehmlich Jugendliche und auchKinder – auf Teufel komm raus programmierten.Es war die Zeit des Commodore 64, kurz C64genannt. Er stand in fast jedem Kinderzimmer,hatte eine weltweite Verbreitung und müsste sichvor heutigen PCs im Prinzip nicht verstecken.Alles, was PCs heute leisten, konnte der C64auch – natürlich sehr viel langsamer. Und inseinen Arbeitsspeicher würde nicht einmal einheutiger Maustreiber passen.Er hatte aber einen großen Vorteil: er war billigund nach dem Einschalten (Hochbooten gab esnicht) stand sofort die Programmiermöglichkeitin Basic (Beginners Allpurpose SymbolicInstruction Code) zur Verfügung. Das wurde vonden Besitzern kräftig benutzt.Es gibt eine ganze Reihe vonProgrammiersprachen. Für jeden besonderenZweck wurde eine andere entwickelt.Grundsätzlich haben aber alle dieselbe Aufgabe:sie sollen es dem Menschen ermöglichen, sicheiner Maschine verständlich zu machen. Auchwenn es manchmal nicht so aussieht: einComputer ist dumm. Die Maschine führt bravund zuverlässig Programme aus, die in einerForm geschrieben sind, die beide, Mensch undComputer, verstehen.Basic hat den Vorteil, dass es leicht zu erlernenist, verhältnismäßig unkompliziert aufgebaut istund trotzdem zu ganz passablen Ergebnissenführt.Gerade diese Vorzüge ließen Profis die Naserümpfen. Wenn Schüler programmieren konnten,wurde an ihrem Image der geheimnisumwittertenKenner von Computern gekratzt. Folglich wurdeBasic madig gemacht. Man muss allerdingszugeben, dass irrsinnig viel Schrott programmiertwurde.

Dieses Vorurteil gegenüber Basic wird heuteimmer noch gepflegt, auch wenn heimlich großeTeile von Anwendungen nach dem Visual Basic– Prinzip entwickelt werden.Die Umgebung um den Heimcomputer C64entwickelte sich zu einer richtigen Szene. Es gabeine 'hauseigene' Zeitschrift, es gab jede MengeZubehör in jedem Kaufhaus (bis hin zuSchnittstellen für Robotermodelle aus demSpielwarenbereich), es gab Spiele in Hülle undFülle und es gab junge Leute, die ihreProgramme der Öffentlichkeit zur Verfügungstellten. Das war so etwas wie die heutigeShareware-Szene, allerdings öffentlicher.Programmlistings waren jedem zugänglich undProgrammierkniffe und –tricks wurden jedemzugänglich gemacht. Sehr demokratisch, dasGanze.Dann kam der PC; die Firma Commodoreverschlief die Entwicklung, der C64 verschwandund merkwürdigerweise endete damit auch dasprivate Programmieren.Heute haben wir Programmiermöglichkeiten, vondenen man damals nur träumen konnte und daherist es umso unverständlicher, dass sich keineneuen Fan-Clubs bilden.Vielleicht gelingt das ja über diesen Weg.Manuskript und Programme sind mitJugendlichen durchgearbeitet worden. Dabeiwurde die Bandbreite von kompletterUnkenntnis, auch mit Windows, bis zu einigenErfahrungen mit Basic berücksichtigt. Daherwerden einige Leser das Eine oder Andere als zuausführlich beschrieben betrachten, anderevielleicht noch mehr Grundkenntnisse benötigen.

Ich bin ein Opfer der neuen Rechtschreibung, willsagen, ich muss ganz neu lernen. Ich hoffe, eswird mir verziehen, wenn noch nicht alleseinwandfrei richtig ist.

Das Programm


5

Das ProgrammVisual Basic ist ein umfassendes System zurEntwicklung von Anwendungen unter Windows.Es gibt verschiedene Ausgaben oder Editionenund verschiedene Entwicklungen oderVersionen. Derzeit liegt die Version Visual Basic6.0 vor. Eine Edition wäre z.B. die Visual BasicLearning Edition von Visual Basic 6.0. Daraufaufbauend gibt es die Professional Edition.ErwerbDie Learning Edition liegt einem Buch überVisual Basic 6.0 bei. Zitat aus der Readme-Datei:

Das Verzeichnis \VB6 enthält die Ablaufmodell-Edition von Visual Basic 6. Diese Visual Basic-Edition ist gegenüber anderen Visual Basic-Editionen in folgenden Punkten eingeschränkt:

Sie können keine ausführbaren Dateien (.exe)erstellen.

Sie können die meisten Beispiele des Buchesnachvollziehen, die Programmierung vonActiveX-Steuerelementen ist allerdings nichtmöglich.

Sie erhalten keinen Support.

Es gibt keine Online-Hilfe.

Auf vielen CDs von Computerzeitschriften findetman eine kostenlose CCE-Version von VisualBasic 5.0. Sie ist allerdings in Englisch. Zudemkann man durch Stöbern von Zeitschriften-CDseine Version 4.0 finden und installieren. Schülerund Studenten können sich kostengünstig Lern-Editionen besorgen. Die Beschaffung ist zwaretwas umständlich, aber die Vertreiber vonSoftware helfen sicherlich gerne weiter.Kostengründe können es also nicht sein, wennVisual Basic nicht eingesetzt wird.Dieses Heft ist so aufgebaut, dass ab Version 4.0alle Programme entwickelt werden können. Aufdie Einschränkungen der Billig-Ausgaben wirdRücksicht genommen. Alle Einschränkungenhaben für Anfänger keine Bedeutung. Auchwenn davon geträumt wird, eine Internet-Anbindung zu programmieren, müssen zunächsteinmal grundlegende Kenntnisse für den Alltagvorhanden sein. In der Schule wird einem auch

nicht im 1. Schuljahr das Lösen vonquadratischen Gleichungen beigebracht.Visual Basic entwickelt sich immer weiter undlässt kaum Lösungsmöglichkeiten aus. Mit hochspezialisierten Programmiersprachen, diebeispielsweise für komplexe Grafikoperationeneingesetzt werden, kann Visual Basic natürlichnicht konkurrieren, für alltäglicheGrafiklösungen reicht es aber allemal – wie wirsehen werden.InstallationHast du deine Version von Visual Basicerworben, muss das Programm auf der Festplatteinstalliert werden. Zunächst solltest du dirüberlegen, in welchem Verzeichnis du VisualBasic installieren willst. Da ich nicht weiß, wiedu deine Dateiordner organisiert hast, schlage ichvor, die Vorgaben des Installationsprogramms zuübernehmen und das Programm aus demStartmenü heraus zu starten.Wer sich gut mit Windows auskennt, kann sichja einen eigenen Ordner für Visual Basicanlegen, wobei die Pfade möglichst kurzgehalten werden sollten, damit später beimEinsetzen von Pfaden keine ellenlangenDateinamen eingesetzt werden müssen.Du startest die Installation, indem du die CDeinlegst, START | AUSFÜHREN | DURCHSUCHENwählst und im CD-Laufwerk VB6\SETUP.EXEaktivierst. Durchweg kannst du einfach aufWEITER klicken, die Lizenzbedingungenbestätigen und den gewünschten Pfadübernehmen oder einen eigenen anlegen.Zwischendrin wird der Rechner einmal neugestartet, wobei du die CD nicht aus demLaufwerk entfernen darfst.Schließlich erscheint die Meldung, dass dieInstallation erfolgreich abgeschlossen wurde.Im Verlauf dieses Heftes werden verschiedeneProgramme entwickelt, die irgendwo gespeichertwerden müssen. Daher solltest du dir wegen derbesseren Übersichtlichkeit einen Ordner anlegen,in dem du die Dateien speicherst. Da dasRegister VORHANDEN im Startdialog desProgramms als Standard auf den Ordner VB98verweist, passt hier ein Ordner PROGRAMME hin.

Starten


6

Starten

Visual Basic kann auf unterschiedliche Weisegestartet werden. Der üblichste Weg ist wohl:STARTMENÜ | PROGRAMME | MICROSOFT VI-SUAL BASIC 6.0 | MICROSOFT VISUAL BASIC 6.0.

Inmitten von vielen Fenstern wartet dasDialogfeld zur Auswahl der Projekte auf dich.Vorgewählt ist STANDARD-EXE im RegisterNEU. Außerdem gibt es die RegisterVORHANDEN und AKTUELL. Im RegisterVORHANDEN werden Verzeichnisse geöffnet, indenen sich Projekte befinden; im RegisterAKTUELL sind alle schon einmal geöffnetenProgramme abgelegt. Hier findest du deine neuentwickelten Programme wieder, nachdem du siegespeichert hast.Bei dir sieht die Sache vermutlich so ähnlich auswie in der nebenstehenden Abbildung. Hiermarkierst du STANDARD.EXE und wählstÖFFNEN, worauf das Programm loslegt.

EinrichtenJetzt hast du Visual Basic in aller Pracht vor dir.Als erstes solltest du das PROJEKT-Fensterverkleinern, indem du mit der Maus an denunteren Rand fährst (der Mauszeiger ändert seineForm) und den Fensterrand nach oben ziehst;dadurch vergrößert sich das EIGENSCHAFTEN-

Fenster – und das brauchen wir ständig. Alsosollten wir es auch unbedingt etwas breitermachen. Das FORMULAR-LAYOUT-Fensterdagegen klickst du weg – das brauchen wirvorläufig nicht.

Starten


7

Die FORM ist die Bedienoberfläche des späterenProgramms. Je nach den Bedürfnissen kann seineGröße einfach verändert werden, indem du diesogenannten ANFASSER, also die kleinenKästchen an der FORM, mit der Maus greifst, d.h.anklickst und dann bei gehaltener Maustaste anihnen ziehst, wodurch sich die FORM vergrößertbzw. verkleinert. Die FORM ist im FORMULAR-DESIGNER-Fenster angelegt – dessen Titelleistezeigt also ganz logisch den Namen PROJEKT1 –FORM1 (FORM) an.Es gibt noch eine ganze Reihe individuellerEinstellmöglichkeiten, die du vornehmlich unterEXTRAS | OPTIONEN findest.

BeschreibungSehen wir uns nun die einzelnen Fenster an – mitihrer Hilfe gestaltet du das Programm, das duentwickeln möchtest.Projekt-FensterIm PROJEKT-FENSTER werden alle Zutaten zueinem Projekt gesammelt. Dazu gehörtstandardmäßig eine Form. Es können nochandere Formen oder Module dazukommen.In der Symbolleiste des Projekt-Fensters gibt esdrei Schaltflächen:CODE ANZEIGEN,OBJEKT ANZEIGEN,ORDNER WECHSELN.Über diese Schaltflächen kannst du vom Objekt(das ist hier die Form mit dem Namen FORM1)zum CODE-Fenster wechseln. Das Code-Fensterzeigt dir natürlich noch nichts an, denn wir habenja noch keinen Code. Genaueres über das Cofe-Fenster erfährst du auf Seite 14.

Den Begriff Code kennst du sicher. Damit wirdmeistens Geheimschrift oder auch Chiffreverbunden. So ähnlich sieht der Code für VisualBasic auch für einen Laien aus. Dieses Heft solldafür sorgen, dass Visual Basic-Code für dichkeine Geheimschrift mehr ist.

Eigenschaften-FensterMenschen gibt es in vielen Formen: groß oderklein, dick oder dünn, mit verschiedenen Namenusw. All das sind Eigenschaften. Jedes Objekt inVisual Basic hat natürlich auch seineEigenschaften, wobei eine Linie wenigerEigenschaften hat als ein Kreis. Eine Linie hat

einen Start- und einen Endpunkt, eine bestimmteDicke, unterschiedliche Farben. Ein Kreis hateinen bestimmten Radius, kann mit Farben oderMustern ausgefüllt sein usw.Diese und andere Eigenschaften findest du imEIGENSCHAFTEN-Fenster. Oben im Fenster siehstdu die Objektliste, in der im Moment nur dieForm zu finden ist. Darunter sind zwei Register,in denen du nach Geschmack die Anzeige derEigenschaften einstellen kannst. Die linke Spalteführt die EIGENSCHAFTEN auf (leider nur inEnglisch) und die rechte Spalte diedazugehörigen WERTE. Diese Werte könnendirekt im Eigenschaften-Fenster verändertwerden.1. Du klickst auf BACKCOLOR, also auf die

Hintergrundfarbe,2. ... dann auf den Pfeil in der Werteliste,3. ... dann auf PALETTE

4. ... und endlich auf eine Farbe Visual Basic führt die Veränderungen jeweils

sofort aus – fertig!5. Nun wählst du AUSFÜHREN | STARTEN oder

drückst F5 bzw. die entsprechendeSchaltfläche in der Symbolleiste.

Fährst du mit dem Mauszeiger über eineSchaltfläche, erscheint nach einem kurzenAugenblick ein sogenannter Tooltip.

Was du jetzt siehst, ist die Bedienoberflächewährend der Laufzeit, d.h. das Programmläuft jetzt. Arbeitest du an derBedienoberfläche, bist du also in derEntwicklungsphase.

6. Du aktivierst AUSFÜHREN | BEENDEN bzw.drückst auf die SCHLIEßEN-Schaltfläche derForm oder die entsprechende Schaltfläche inder Symbolleiste.

Mit der dritten Schaltfläche in diesemZusammenhang kannst du den Programmablaufunterbrechen, um Überprüfungen des Programmsvorzunehmen.Die einzelnen Eigenschaften werden im Laufeder Programmentwicklung besprochen. Imübrigen ist unter dem EIGENSCHAFTEN-Fenstereine Kurzbeschreibung zu sehen, ansonsten gilt:Lernen durch Ausprobieren.

Starten


8

Werkzeug-FensterDas Werkzeug-Fenster beinhaltet diesogenannten Werkzeuge oder Tools. Damitwerden vorgefertigte Steuerelemente für dieBedienoberfläche zur Verfügung gestellt.Auch hier erschient wieder ein Tooltip mit der(leider) englischen Bezeichnung.

Tooltip DeutschZEIGER Zeiger

PICTUREBOX Bildfeld

LABEL Bezeichnungsfeld

TEXTBOX Textfeld

FRAME Rahmen

COMMAND-BUTTON

Befehlsschaltfläche

CHECKBOX Kontrollkästchen

OPTION-BUTTON

Optionsfeld

COMBOBOX Kombinationsfeld

LISTBOX DateilisteHSCROLLBAR Horizontale

BildlaufleisteVSCROLLBAR Vertikale Bildlaufleiste

TIMER Zeitgeber

DRIVELIST-BOX

Laufwerksfeld

DIRLISTBOX Verzeichnislistenfeld

FILELISTBOX Dateilistenfeld

SHAPES FigurenLINE LinieIMAGE Bildanzeigefeld

DATA Datensteuerelement

OLE Datenverknüpfungüber OLE

Dieses Fenster kann durch unzählige Werkzeugefür jeden erdenklichen Zweck ergänzt werden.Das machst du so: du wählst DATEI | NEUESPROJEKT, verneinst die Abfrage nach Speichernund wählst VB ABLAUFMODELL-EDITION-STEUERELEMENTE. Nun werden zusätzlicheSteuerelemente geladen, die wir in diesem Heftaber nicht verwenden werden.Über DATEI | NEUES PROJEKT – und Verneinungder Abfrage nach Speichern – aktivierst du dieSTANDARD.EXE und kehrst so wieder in denAusgangszustand zurück.Wie bekommst du nun die Schaltflächen auf dieForm? Wie immer bei Visual Basic gibt esmehrere Möglichkeiten. Du kannst:• eine Schaltfläche anklicken, den Mauszeiger

in die Form setzen, die linke Maustastedrücken und bei gedrückter Maustaste einRechteck aufziehen. Fertig!

• die Schaltfläche im Werkzeugfensterdoppelklicken. Fertig!

Alle Schaltflächen haben Anfasser, mit denen dudie Größe der Schaltfläche verändern kannst; dieSchaltfläche kann bei gedrückter linkerMaustaste auch verschoben werden.Es kann jeweils nur eine Schaltfläche aktiv sein –welche, das ist an den Anfassern zu erkennen. ImEigenschaften-Fenster werden die jeweiligenEigenschaften für die Schaltfläche automatischangezeigt. Willst du die Eigenschaften für eineSchaltfläche ändern, kannst du sie in der Formanklicken und sie aktivieren oder in derAuswahlliste des Eigenschaften-Fenstersanwählen.

Form-FensterDas FORM-Fenster wird meistens nur Form oderFormular genannt. Hier findet die Gestaltungdeiner Anwendung statt. Auf der Form, oder mansagt auch in der Form, werden die Objekteangeordnet, die in ihrer Kombination dieBedienoberfläche ergeben. Beim Start desProgramms ist dann nur noch die Form mit ihrenElementen aktiv und wartet darauf, dass etwasgeschieht.

Starten


9

In der offiziellen Version von Visual Basic 6 gibtes die Möglichkeit, eine sogenannte EXE-Dateizu erstellen. Wenn du genau hinsiehst, kannst duim Datei-Menü ein abgeblendetes Menü namensPROJEKT1-EXE ERSTELLEN erkennen. Damitwird ein ausführbares Programm entwickelt, dassdu auch auf Rechnern ausführen kannst, aufdenen kein Visual Basic installiert ist. DieseMöglichkeit ist auf dieser Testversion leider nichtvorhanden.

Die Form ist in das FORMULAR-DESIGNER-Fenster eingebettet. In der Titelleiste der Formsiehst du die Beschriftung (Caption) der Form.Die änderst du, indem du im Eigenschaften-Fenster die Eigenschaft Caption wählst und einenanderen Wert eingibst. Etwas verwirrend ist, dassdie Form auch den Namen Form1 hat. Daskannst du im Eigenschaften-Fenster bei derEigenschaft Name sehen. Den namen kannst dunatürlich ändern. Unter diesem namen wird dieForm im Programm angesprochen.Wie du siehst, übernimmt Visual Basic deineEingaben sofort in die Titelleiste der Form. Hiersiehst du also auch, wie einfach es ist,Eigenschaften zu benutzen: du musst nur in derEigenschaftenliste eine Eigenschaft auswählenund in der Werteliste einen neuen Werteintragen.Die Eigenschaft CAPTION gibt es für die meistenSteuerelemente. Übersetzt heißt das in etwaÜberschrift, Beschriftung.Die Form hat ein Punkteraster, das während derLaufzeit verschwindet. Es ist nur dazu da, dieAnordnung der Steuerelemente ziemlich genauvornehmen zu können.

Willst du die Rastereinstellungen verändern, tustdu das über EXTRAS | OPTIONEN | ALLGEMEIN.Wie du siehst, kannst du hier jede MengeEinstellungen vornehmen. Solange du dich nichtgut genug auskennst, solltest du die Standard-Einstellungen beibehalten.

Hier folgt nun eine Liste der Eigenschaften:Eigenschaft BeschreibungNAME Name der FormBORDERSTYLE Rahmentyp der FormBACKCOLOR HintergrundfarbeFORECOLOR SchriftfarbeCONTROLBOX Systemmenüfeld (in der

Titelleiste links),sichtbar, unsichtbar.

FONT Schriftarten inFormularen.

ICON Legt das Symbol fest,das angezeigt wird,wenn das Formularsminimiert wird.

MAXBUTTON Legt fest, ob dieSchaltflächeMaximieren beimProgrammablaufangezeigt wird odernicht.

MINBUTTON Legt fest, ob dieSchaltfläche Minimierenbeim Programmablaufangezeigt wird odernicht.

STARTUPPOSITION Legt die Position desFormulars fest.

WINDOWSTATE Legt fest, ob dasFormular maximiert,minimiert oder normalangezeigt wird.

Basic


10

BasicEs gibt Konzepte, die in jedem Basic-Dialektgelten, also nicht nur in Visual Basic. Einigedavon sollen an dieser Stelle besprochen werden.

CodeEin Code besteht zu einem großen Teil ausAnweisungen, die man auch Befehle nennt. DerComputer wird angewiesen, bestimmte Aktionenvorzunehmen. Anweisungen werden nacheinan-der ausgeführt. Das üblichste Beispiel ist immerwieder die Anweisung Print "HalloWelt!", die dazu führt, dass der Computer'Hallo Welt' auf die Form schreibt. Print ist derBefehl., "Hallo Welt!" ein Argument. DerComputer 'versteht' den Code aber nur, wenn erohne Fehler ist – jeder Schreibfehler wird miss-verstanden. Deshalb muss man bei den Anwei-sungen genau aufpassen. Das Argument, eineVariable, kann so fehlerhaft sein wie es will.Alles, was innerhalb der Anführungszeichensteht, wird genauso wiedergegeben, also auchmit sämtlichen Schreibfehlern. Zum Glück hilftVisual Basic nach Kräften, Fehler zu vermeiden.

VariablenJede Programmiersprache lebt von der Vielfaltder möglichen Variablen. Eine Variable ist einWert mit veränderlicher Größe, ein Platzhalter,in den Werte eingesetzt werden können –gewissermaßen ein Schubfach mit einem Namenin einem Schrank, in das man etwas hineinlegt,was man dann bei Bedarf wieder herausholt.

Sehm wir uns das obige Beispiel genauer an:1. Satz = "Hallo Welt!"2. Print SatzIn Zeile 1 legst du den Wert "Hallo Welt!"in ein Schubfach mit dem Namen Satz. In Zeile2 gibst du folgende Anweisung: Schreibe denInhalt des Schubfaches 'Satz' oder aufcomputerisch: schreibe die Variable 'Satz'.Änderst du den Inhalt, wird der alte Inhaltschlicht überschrieben.1. Satz = "Hallo Welt!"2. Print Satz3. Satz = "Guten Tag, schöne

Welt!"4. Print SatzDer Computer würde jetzt beide Inhalteuntereinander auf den Bildschirm schreiben. Wiedas gemacht wird, dazu kommen wir später.Für fast jeden Zweck gibt es unterschiedlicheVariablentypen. Damit wird auf den jeweiligenInhalt einer Variablen Rücksicht genommen. Esist nicht egal, ob der Inhalt, bzw. der Wert einerVariablen eine Zahl, ein Wort oder einGeldbetrag ist. Die Unterschiede hängenvornehmlich mit dem Speicherbedarf und damitmit der Rechengeschwindigkeit zusammen.Der Einsatz der Variablen wird jeweils in denProgrammprojekten besprochen.

Variablentyp Inhalt (Wert) WertebereichBYTE Ganzzahl 0 - 255INTEGER Ganzzahl -32.768 – 32.767LONG Fließkomma -2.147.483.648 – 2.147.483.647SINGLE Fließkomma riesengroße WerteDOUBLE Fließkomma noch größere WerteCURENCY Währung -922.337.203.685.477, 5808 - + wie bei -DATE Datum/Zeit 1. Januar 100 – 31. Dezember 9999STRING Text Ca. 65.500 ZeichenVARIANT alle variabelBOOLEAN Boole True oder False (-1 oder 0)

Variablen


11

Variablen deklarierenVariablen benötigen einen Namen, und dieserName muss grundsätzlich mit einem Buchstabenbeginnen. Die Zeichen können aus Buchstaben,Ziffern und dem Unterstrich ( _ ) bestehen.Damit sind eindeutige Variablennamen möglich,z.B. Zeugnis_Mathe, Einnahme_Ver-kauf, Einnahme1 o.ä.Es ist ein guter Brauch, Variablen zu deklarieren,d.h. bei Visual Basic anzumelden. Dazu wird dieAnweisung Dim verwendet. z.B.:Dim Satz As String

Damit bekommt die Variable den Namen Satzund Visual Basic wird mitgeteilt, dass der Wertvom Typ Zeichenkette (STRING) sein muss.Visual Basic wird zukünftig mit einerFehlermeldung meckern, wenn der Wert derVariablen nicht stimmt – z.B. wenn du eine Zahlbenutzt.Willst du sichern, dass du nicht vergisst,Variablen zu deklarieren, kannst du Visual Basicdazu veranlassen, dich energisch daran zuerinnern. Dazu wählst du EXTRAS | OPTIONENund das Registerblatt EDITOR. Dort aktivierst dudie Option VARIABLENDEKLARATIONERFORDERLICH, wählst DATEI | NEUES PROJEKT– das Speichern verneinst du – und wählstendlich STANDARD.EXE. Der Neustart ist nötig,damit die Anweisung OPTION EXPLICIT aktiviertwird, die dafür da ist, die Variablendeklarationzu erzwingen.

Der Wert dieser Anweisung liegt vor allem darin,dass Tippfehler in Variablennamen von VisualBasic bemerkt werden. Nehmen wir an, du hastdie Variable Satz deklariert. Im Verlauf derProgrammierung willst du die Variable benutzenund schreibst irrtümlich z.B. Sazz. Für denComputer ist das eine neue Variable, die nichtdeklariert ist – weswegen er sich entsprechendmeldet. Das ist zwar manchmal lästig, beiumfangreicheren Programmen aber sehr

hilfreich. Außerdem zeigt dir Visual Basic auchgleich an, um welche Variable es sich handelt –nämlich die farblich unterlegte.GeltungsbereichWichtig sind auch Geltungsbereich und -dauerder Variablen. Das erläutern wir später konkretan Beispielen.VariablenwerteDas Gleichheitszeichen hat keine mathematischeBedeutung, sondern ist ein Zuweisungszeichen:Dim Satz As String

Dim Zahl As Integer

Dim Grosse_Zahl As Double

Satz = "Hallo Welt, mir geht esgut!"

Zahl = 123

Grosse_Zahl = 23632.143

Es wird der Variablen ein Wert zugewiesen,wobei eine Zeichenkette (String) auch ein Wertist.

Zeichenketten müssen grundsätzlich inAnführungszeichen gesetzt werden.Dezimalzahlen müssen grundsätzlich mit einemPunkt (.) und nicht mit einem Komma (,)geschrieben werden.

KonstantenEs tauchen in Programmen immer wiederZahlenwerte auf, die sich nicht verändern, diealso konstant sind. Beispiele sind derMehrwertsteuersatz von 16% oder die Zahl Pibei mathematischen Berechnungen. Pi hat mitgenügender Genauigkeit den Wert 3,1415926546. Solche Werte werden inbenutzerdefinierten Konstanten mit derAnweisung CONST angelegt.Const Pi As Single = 3.1415926546Im Gegensatz zu Variablen lässt sich der Werteiner Konstanten also nicht ändern – ansonstengelten für Konstanten gleiche Bedingungen wiefür Variablen.Visual Basic stellt eine Unzahl vonsystemdefinierten Konstanten zur Verfügung.Diese Konstanten liegen fertig vor und müssennicht festgelegt werden. Wir werden sie in denProgrammen verwenden.

Operatoren


12

OperatorenStandardoperatorenDie Standardoperatoren kennst du aus derSchule. Es sind die Zeichen für Plus, Minus, Malund geteilt durch (+, -, *, /). Diese Zeichenkannst du in Visual Basic genauso einsetzen, wiein der Schule. Wenn du ausrechnen willst,wieviel 236 * 14 / 536 ist, nimmst du deinenTaschenrechner oder Visual Basic. Dudoppelklickst auf die Form, worauf sich dasCodefenster öffnet. Hier sind grundsätzlich dieerste und die letzte Zeile vorgegeben:Private Sub Form_Load()

End Sub

Du setzt selber die folgenden Zwischenzeilendort ein, wo der Textcursor bereits blinkt:2. Show3. Print 236 * 14 / 536

Wie du siehst, habe ich vor jede Zeile eineNummer gesetzt. Das dient nur der Orientierung,darf aber keinesfalls bei der eigentlichenProgrammierung Anwendung finden.Im übrigen befassen wir uns auf Seite 14 genauermir dem Aufbau von Prozeduren.

Zeile 2 ist die Anweisung für ANZEIGEN; Zeile 3die Anweisung, die Werte auszurechnen und indie Form zu schreiben.Drückst du nun auf F5 oder wählst AUSFÜHREN |STARTEN, erscheint in der Form der Wert6,16417910447761.Abschließend drückst du auf die SCHLIEßEN-Schaltfläche der Form oder auf ALT + F4 bzw.wählst AUSFÜHREN | BEENDEN.VergleichsoperatorenWie der Name schon sagt, vergleichen dieseOperatoren zwei Werte miteinander. Ist ein Wertkleiner als ein anderer Wert, ist er größer oder ister gleich? Manchmal ist es wichtig zu wissen, obein Wert ungleich einem anderen ist.In Programmen finden meistens in diesemZusammenhang Fragestellungen statt; wennWert1 größer ist als Wert2, dann ....Im Computer wird die Frage immer nurdaraufhin überprüft, ob das Ergebnis wahr(TRUE) oder falsch (FALSE) ist. Die Wertekönnen auch Wörter sein. Ist Erwin <

Klaus bezieht sich nicht die Körpergröße,sondern das Programm würde prüfen, ob Erwinmit dem Anfangsbuchstaben E im Alphabet vorKlaus mit dem Anfangsbuchstaben K liegt. Indiesem Fall wäre das Ergebnis wahr (true)Ope-rator

Beispiel Bedeutung

= Wert1 = Wert2 Wert1 ist gleichWert2

<> Wert1 <> Wert2 Wert1 istungleich Wert2

> Wert1 > Wert2 Wert1 ist größerals Wert2

< Wert1 < Wert2 Wert1 istkleiner alsWert2

>= Wert1 <= Wert2 Wert1 ist größerals oder gleichWert2

<= Wert1 <= Wert2 Wert1 istkleiner als odergleich Wert2

Logische OperatorenManchmal sollen Programmabläufe davonabhängig sein, dass mehrere Werte gleichzeitigzutreffen. Wenn Wert1 und Wert2 und Wert3oder Wert4 zutreffen, dann .... Das kann VisualBasic natürlich auch. Dafür werden logischeOperatoren verwendet. Sie verknüpfen dieWerte. Nach der Verknüpfung wird wiedergeprüft, ob die Gesamtaussage zutrifft, wahr istoder nicht zutrifft also falsch ist.Ope-rator

Beispiel Bedeutung

AND Wert1 ANDWert2

beide Wertesind wahr,treffen zu

OR Wert1 ORWert2

ein Wert vonbeiden ist wahr,trifft zu

NOT NOT Wert1 der Wert1 trifftnicht zu

Es gibt noch mehr logische Operatoren, die wiraus Platzgründen hier nicht erwähnen.

Funktionen


13

FunktionenEs tauchte der Begriff Anweisung auf. Ein Basic-Programm besteht größtenteils aus Anweisungen,also Befehlen, die der Computer ausführt. Es gibtaber auch Funktionen.Numerische FunktionenEine häufig verwendete Funktion ist Len –vom englischen Wort Length. Sie ermittelt dieLänge einer Zeichenkette: du doppelklickst in dieForm, löschst eventuellen Code und setzt denCode für PROGRAMM2 ein:1. Private Sub Form_Load()2. Show3. Dim Zeichenkette As String4. Dim länge As Integer5. Zeichenkette = "Es ist ein

schöner Tag!"6. länge = Len(Zeichenkette)7. Print länge8. End SubSchließlich drückst du auf F5.In Zeile 6 wird die Funktion Len eingesetzt, undder Funktionswert wird der Variablen längeübergeben. Als Ergebnis erhältst du 23. Hierwerden auch die Leerzeichen gezählt.Funktion Beispiel BedeutungSQR Sqr(25) es wird die

Quadratwurzelermittelt

INT Int(25.1234)

es wird der nächst-kleinere ganzzahligeWert ermittelt (beipositiven Zahlenwerden einfach dieNachkommastellenabgeschnitten)

FIX Fix(25.1234)

entfernt dieNachkommastellen

SIN Sin(90) Der Sinus einesWinkels wirdermittelt

ZeichenkettenfunktionenGrundsätzlich gilt, dass alles, was zwischenAnführungszeichen (Gänsefüßchen) steht, eineZeichenkette ist. "Erwin ist ein guterSchüler." oder "1 Tor hat zum Sieggereicht." ist eine Zeichenkette. Du kannst

alles in Anführungszeichen einschließen, auchSonderzeichen; z.B. "$%231+". Visual Basicinteressiert nur die Länge der Zeichenkette.Zeichenketten kann man manipulieren. Dafürstehen etliche Funktionen zur Verfügung.Funk-tion

Beispiel Bedeutung

LEFT Zeichenkette= Left("Esist einschönerTag!",6)

gibt die Zeichenbis zur 6.Position vonlinks aus

RIGHT Zeichenkette= Right("Esist einschönerTag", 6)

gibt die Zeichenbis zur 6.Position vonrechts aus

MID Zeichenkette= Mid("Esist einschönerTag!", 8, 3)

gibt 3 Zeichenvon der 8.Position vonlinks aus

INSTR Zeichenkette= Instr(1,"Es ist einschönerTag!","Tag")

gibt die Positionvon links an, ander der Suchtextbeginnt

Als Beispiel setzt du nun in den Code ausPROGRAMM2 zwischen den Zeilen 7 und 8folgende Zeilen ein und erhältst so unserPROGRAMM3:Print Left(Zeichenkette,6)

Print Right(Zeichenkette,4)

Print Mid(Zeichenkette,8,11)

Print Instr(1, „Es ist einschöner Tag!“,“Tag“)Vergiss nicht den abschließenden Druck auf F5.In der Abbildung hast du dieZeichenkettenmanipulationenuntereinander. Im Anhang isteine Prozedur Umkehrenvorhanden, die dir zeigt, wieman mit den Zeichenketten-Funktionen eine Zeichenkettevon hinten nach vorn umkehren kann.

Visual Basic


14

Visual BasicVisual Basic umfasst die Grundlagen von Basicsowie umfangreiche Neuerungen. Mit demklassischen Basic ist Visual Basic überhauptnicht mehr zu vergleichen, obwohl im Rahmendieses Heftes die Unterschiede noch nicht allzudeutlich zu erkennen sind. Das klassische Basicwar sozusagen ein Programmwurm, der vornanfing und bis zum Ende abgearbeitet wurde.Visual Basic dagegen ist ereignis- undobjektorientiert und setzt eigentlich dieAnwendung der Maus voraus.Was heißt objektorientiert? Visual Basic verstehtseine Elemente (Fenster, Schaltflächen, Listenusw.) als Objekte, die Eigenschaften haben unddenen man bestimmte Methoden und Ereignissezuordnen kann.Was heißt ereignisorientiert? Programme unterVisual Basic warten auf Ereignisse. Du kannstein Programm starten – und es passiert nichts.Klickst du eine Schaltfläche an, geschieht irgendetwas, aber was, das muss programmiert werden.EigenschaftenEigenschaften wurden schon besprochen. Siesind so wichtig, dass es dafür ein eigenes Fenstergibt. Es gibt aber auch Eigenschaften, die nichtzur Entwicklungszeit eingestellt werden können,sondern im Programm aufgebaut werden müssen.EreignisseJedes Objekt hat unterschiedlich vielMöglichkeiten, auf Ereignisse zu reagieren. Einhäufiges Ereignis ist z.B. der Klick mit der Mausauf eine Schaltfläche. Die möglichen Ereignissewerden von Visual Basic in einer Listedargestellt, die du mit einem Klick auf denkleinen Pfeil rechts neben LOAD öffnest.

Hier siehst du eine lange Liste mit allenEreignissen, die dem Objekt FORM zugeordnetsind. Unmittelbar ist das Ereignis LOADmarkiert. Markiert werden alle eingesetztenEreignisse. Zum Glück braucht man meist nurwenige.MethodenMethoden sehen den Eigenschaften ähnlich,bedeuten aber die Anweisungen an ein Objekt,sich auf eine bestimmte Weise zu verhalten, z.B.eine bestimmte Position auf der Formeinzunehmen oder einer Liste neue Elementehinzuzufügen.

Hilfe-Dateien zu diesem Heft findest du auf derHomepage. Suche die Seite mit derHeftbeschreibung. Dort gibt es einen Link zu derDatei, die du kostenlos downloaden kannst.

Visual Basic


15

ProzedurenUm all das leisten zu können, sind Visual Basic-Programme in sogenannte Prozeduren eingeteilt.Sehen wir uns das an zwei Beispielen an:

Private Sub Form_Load() (Anweisungen)End Sub

Eine Prozedur wird durch das Schlüsselwort Subeingeleitet. Das Schlüsselwort Private zeigtan, dass diese Prozedur von anderen Prozedurenaufgerufen werden kann. Alles, was zwischenSub und End Sub steht, wird vom Computerabgearbeitet, worauf die Prozedur dann wiederverlassen wird. Die oben genannte Sub verweistauf das Objekt Form und durch einen Unterstrichgetrennt auf das Ereignis Load. Alles, waszwischen der Startzeile und der Endzeileeingetragen wird, geschieht beim Laden derForm, also im allgemeinen, wenn man dasProgramm startet.

Private Sub Form_Click()

(Anweisungen)End Sub

Wird das Ereignis Click gewählt, kann Code indie Prozedur geschrieben werden, der ausgeführtwird, wenn auf die Form geklickt wird.Der Code innerhalb einer Ereignis-Prozedur istdurch die beiden Zeilen von allen anderenProzeduren abgeschottet. Auch Variablen ineiner Prozedur sind grundsätzlich nur aktiviert,wenn die Prozedur aufgerufen wird – und ihreWerte sind wieder verschwunden, wenn dieProzedur verlassen wird. Daher kann man auchin Prozeduren die gleichen Variablennamenverwenden, denn eine Prozedur kennt die anderenicht.

FunktionenIn diesem Zusammenhang sind selbstentwickelteFunktionen gemeint, nicht die Funktionen, dieals Basic-Funktionen bekannt sind – und die wirauf Seite 13 besprachen – wie z.B. die FunktionSIN(WINKEL).Über diese mathematische Funktion wird derSinus eines Winkels berechnet.Funktionen dieser Art sind in Basic eingebaut.Wir wollen jetzt aber über Funktionen sprechen,die wie Prozeduren aufgebaut sind, aber einenWert an das Programm zurückgeben. Wenn ineinem Programm immer wieder Mehrwertsteuernberechnet werden, legt man für diesen Zweckeine Funktion an und übergibt dieser dieentsprechenden Beträge. Die Funktion gibt denberechneten Betrag zurück.

Private FunctionMehrwertSteuer(Betrag)

BerechnungenMehrwertSteuer =ErgebnisBerechnungen

End FunctionSelbstentwickelte Funktionen verhalten sich alsoim Grunde genauso wie die integriertenFunktionen. Ein Beispiel für die Verwendungvon Funktionen ist im Anhang auf Seite 55beschrieben.

Das erste Programm


16

Das erste ProgrammDie Voraussetzungen für einen ersten Versuchsind geschaffen. Visual Basic stellt dir eine Formund ein Werkzeugfenster zur Verfügung, und diegrundlegenden Kenntnisse hast du. Fehlt nurnoch eine Idee.Ich habe bei den Programmiervorschlägenweniger an verwertbare Programme gedacht, alsvielmehr an Programmiertechniken. Wir wollenmöglichst viele Techniken kennen lernen – dasbedeutet aber, dass ein eleganterer Code verlorengeht. Mit zunehmenden Kenntnissen kannst dudeine eigenen Vorstellungen entwickeln.Ratsam ist, sich optisch zunächst an dasWindows-Aussehen zu halten. IndividuelleGestaltungen können nicht über unsaubereProgrammierung hinwegtäuschen. SchlechteBeispiele findest du zuhauf im Freeware-undShareware-Bereich.BedienoberflächeAls erstes Beispiel soll ein Würfelspielprogrammiert werden. Der Computer würfelt,und der Anwender soll die Augenzahl raten. DasErgebnis wird angezeigt und ausgewertet. Fürdieses Programm benötigst du ein Bildfeld,sieben Formen für die Augen, sechsBefehlsschaltflächen für den Tipp, eineBefehlsschaltfläche fürs Beenden desProgramms, drei Bezeichnungsfelder für dieAnzeigen der Treffer und zweiBezeichnungsfelder für Beschriftungen.

Form.HEIGHT Höhe ca. 5200WIDTH Breite ca. 5800CAPTION Beschriftung Würfelspiel

Den Wert einer Eigenschaft veränderst du ganzeinfach, indem du sie anklickst und einen neuenWert eingibst, wodurch der alte Wertüberschrieben wird. Ein Druck auf EINGABEsetzt die Eigenschaft sofort um. Du kannst alsobei Breite oder Höhe der Form die Wirkungsofort sehen und, falls nötig, einen anderen Werteingeben.Willst du eine Eigenschaft in der Liste ansteuern,machst du das so: du drückst STRG+UMSCHALT

und dann den Anfangsbuchstaben dergewünschten Eigenschaft. Sind mehrereEigenschaften mit gleichem Anfangsbuchstabenvorhanden, tippst du einfach noch einmal denselben Buchstaben.

PictureBoxNAME Name picWürfelWIDTH Breite ca. 3000HEIGHT Höhe ca. 3000TOP Abstand vom oberen

Randca. 350

LEFT Abstand vom linkenRand

ca. 350

1. m Werkzeugfenster doppelklickst du aufdie PICTUREBOX ...

2. ...und gibst im EIGENSCHAFTEN-Fenster dieobigen Werte ein

3. Dann klickst du auf SHAPE – Vorsicht,nur ein einfacher Klick, da du dieeinzusetzende Objekt andernfalls nichtbearbeiten kannst! ......

4. ... ziehst ein Kästchen im Bildfenster auf undplatzierst es links oben ...

5. ... und wiederholst diesen Prozess, bis duinsgesamt sieben Kästchen wie in derAbbildung angeordnet hast.

Dass sieben 'Augen' benötigt werden, hat seinenGrund, den du noch erfahren wirst.

Das erste Programm


17

Im EIGENSCHAFTEN-Fenster ist die EigenschaftSHAPE (Figur) markiert. Klickst du auf denkeinen Pfeil im der Werteliste, öffnet sich eineweitere Auswahlliste mit den möglichen Figur-optionen. Dort findest du unter der Ziffer 3 dieOption KREIS.Nun kann man die Kästchen einzeln in Kreiseverwandeln – das lässt sich aber auch einfachererledigen – du hältst STRG, während du mit derMaus die Kästchen nacheinander anklickst,worauf alle hierdurch markierte ObjekteAnfasser erhalten. Anders augedrückt gruppierstdu die Objekte. Klickst du dann die OptionKREIS an, verwandeln sich alle Kästchen aufeinen Schlag in Kreise. Vergiss nicht die Werteeinzugeben:

ShapeHeight Höhe 700Width Breite 700

1. Klickst du in das Bildfeld, wird dieGruppierung aufgehoben

2. Du ordnest die Kreise der Augen wie beieiner Sechs an, indem du sie jeweils anklickstund korrekt platzierst.

3. Das siebte Auge setzt du wie in derAbbildung genau in die Mitte.

4. Du ordnest die 'Augen' so an,

dass die Durchnumerierungvon Shape1 bis Shape6 vonlinks nach rechts erfolgt unddie Figur in derMitte Shape7ist. Dann passt du das Bildfeld so an, dass einoptisch ausgewogener Eindruck entsteht.

5. Nun doppelklickst du aufCOMMANDBUTTON

6. Die Schaltfläche platzierst du oben rechtsneben dem Bildfeld – wie das bei miraussieht, siehst du in der Darstellung desEndergebnisses.

7. Im Eigenschaftenfenster machst du folgendeAngaben:CommandButtonNAME Name cmdSchließen

CAPTION Beschriftung Schließen

8. Dann doppelklickst du auf die neueSchaltfläche, die inzwischen ihren NamencmdSchließen erhalten hat.Es öffnet sich das Code-Fenster mit demProzedurrahmen für das Ereignis CLICK.Visual Basic vermutet klugerweise dasWahrscheinlichste, und das ist bei einemBefehlsbutton nun einmal ein Klick.

9. Dort, wo der Cursor blinkt, schreibst du end.Damit Program-Listings übersichtlichbleiben, rückt man im allgemeinenBefehlszeilen um einen Tabstop ein. AlsoTAB und end schreiben.Visual Basic wandelt dein end in End umund färbt es blau ein – so teilt dir dasProgramm mit, dass der Befehl korrektgeschrieben und von Visual Basic erkanntwurde. Die Sache sieht also so aus:Option ExplicitPrivate Sub cmdSchliEßen_Click() EndEnd Sub

Abschließend drückst du wie immer F5, woraufdas Programm startet. Mit einem Klick auf dieBefehlsschaltfläche kannst du es wieder beenden.Du hast gesehen, wie einfach es sein kann, demComputer Befehle zu erteilen. Leider geht esnicht immer so unproblematisch. Immerhinkennst du schon die erste Anweisung, nämlichEnd.Der nächste Punkt in unerer Programmierung isteine Geschmacksfrage. Es geht um die farblicheAusgestaltung des Würfelspiels – wir wollen dasgraue Einerlei etwas auffrischen. Für dieseAufgabe benutzt du selbstverständlich wiederdas EIGENSCHAFTEN-Fenster.

1 2

3 7 4

5 6

Das erste Programm


18

1. Du schließt das CODE-Fenster bw. klickst inden sichtbaren Teil der Form, so dass diesewieder im Vordergrund steht.

2. Dann klickst du einen Kreis an, ...3. ... öffnest, falls notwendig, die AUSWAHL-

LISTE über den Pfeil...4. und machst folgende Angaben:

Shapes1 - 7FILLSTYLE Füllstil ausgefülltFILLCOLOR Füllfarbe aussuchenBORDERWIDTH Randstärke 3BORDERCOLOR Randfarbe aussuchen

Probiere an einem SHAPE alle möglichenEinstellungen aus. Wenn du dich entschiedenhast, werden die Augen wieder gruppiert unddie Einstellungen erneut vorgenommen..

5. Bei der Gelegenheit kannst du dem Bildfeldgleich eine passende Hintergrundfarbe geben:du klickst in eine freie Stelle des Bildfeldesbzw. wählst in der AUSWAHLLISTE oben imEIGENSCHAFTEN-Fenster den Punkt PICWÜR-FEL, wodurch das Bildfeld aktiviert wird.picWürfelBackColor Hintergrundfarbe aussuchen

Je nach Geschmack sieht der Würfel jetztschön bunt aus. Fehlen noch dieBefehlsschaltflächen für den Tipp desSpielers.

6 Also doppelklickst du sechs Mal aufCOMMANDBUTTON im WERKZEUG-Fenster,worauf sechs Buttons übereinander in derMitte der Form angelegt werden.

7 Diese Buttons ordnest du auf der rechtenSeite der Form an, unter der SCHLIESSEN-Schaltfläche, und gruppierst sie.

8 Im EIGENSCHAFTEN-Fenster wählst duWIDTH und trägst 372 ein.Visual Basic legt standardmäßig die Höheeines COMMANDBUTTON mit 372 fest, sodass bei derselben Breite eine quadratischeSchaltfläche entsteht.

9 Dann machst du folgende Angaben:

10

Command1 – Command6NAME Name cmdEins,

cmdZwei,cmdDrei,cmdVier,cmdFünf,cmdSechs

CAPTION Beschriftung 1,2,3,4,5,6

Es erleichtert die Übersicht, wenn man sichangewöhnt, jedem Namen eine Kennungbeizufügen, z.B. CMDEINS oder PICWÜRFEL.Für die FORM und das PROJEKT behältst duallerdings die Standardbezeichnungen – hiergibt es kaum Identifikationsprobleme.

10 Nun klickst du drei Mal LABEL an und ziehstdie drei Bezeichnungsfelder auf der Form auf.

11 Im EIGENSCHAFTEN-Fenster machst dufolgende Angaben:Label1

NAME Name lblVerloren

CAPTION Beschriftung 00

BORDER-STYLE

Rahmenstil Fest Einfach

FONT(Größe)

Schrift 14

AUTOSIZE Automatische Anpassung

True (Wahr)

ALIGNMENT Ausrichtungder Anzeige

Zentriert

Label2

NAME Name lblGewonnen


BORDER

STYLE


FONT(Größe)

Schrift 14

AUTOSIZE AutomatischeGrößenanpassung

True (Wahr)

ALIGNMENT Ausrichtungder Anzeige

Zentriert

Das erste Programm


19

Label3

NAME Name lblAnzeige

CAPTION Beschriftung Anzeige

BORDER-STYLE


FONT(Größe)

Schrift 18

ALIGNMENT Ausrichtungdes Textes

Zentriert

Zur Einstellung der Eigenschaften gibt esnicht viel zu sagen. Du wählst die jeweiligenEigenschaften, die dazugehörigen Wertetippst du ein, bzw. wählst sie aus derAuswahlliste, die sich bei einigenEigenschaften öffnen lässt.

12 Die Bezeichnungsfelder LBLVERLOREN undLBLGEWONNEN sollen so groß sein, dass einezweistellige Zahl genau hineinpasst. Deshalbwird als Wert die CAPTION 00 gesetzt undAUTOSIZE auf TRUE gestellt.

13 Naturgemäß beginnt die Anzeige mit einereinstelligen Zahl zu zählen. Visual Basicwürde die Größe des Bezeichnungsfeldesentsprechend anpassen. Um das zuverhindern, lassen wir Visual Basic dieoptimale Größe mit AutoSize = Trueanpassen und schalten dann die AUTOSIZEwieder auf FALSE.

14 Wenn du jetzt noch die EigenschaftAlignment, also die Ausrichtung der Anzeigeim Feld auf zentriert stellst, wird dieeinstellige Anzeige mittig dargestellt.

Für einen Programmablauf sind solcheFeinheiten unwichtig; für eine sorgfältigePräsentation eines Programms aberunerlässlich.

15 Die Eigenschaftswerte True und Falsehaben hier etwa die Bedeutung voneingeschaltet, ausgeschaltet.

16 Das Anzeigefeld LBLANZEIGE passt du in derGröße so in die Form ein, dass es möglichstprofessionell aussieht.

17 Durch den Wert Zentriert der EigenschaftAlignment werden die Anzeigen immer mittigdargestellt.

18 Selbstverständlich kannst du dir nochSchriftfarben oder andere Schrifttypenaussuchen.

19 Zum Schluss werden noch dieBezeichnungsfelder für die Beschriftung derTrefferzähler angeordnet:Label1CAPTION Beschriftung Verloren

AUTOSIZE AutomatischeAnpassung

True

Label2CAPTION Beschriftung Gewonnen

AUTOSIZE AutomatischeAnpassung

True

Bei Steuerelementen, die im Programm nichtwieder angesprochen werden, wie hier z.B. beireinen Beschriftungen, lasse ich die Namenbestehen. Es gibt keinen Sinn, sich Namenauszudenken, die gar nicht verwendet werden.Anders ist das, wenn im Laufe des Programmsdie Werte geändert werden.

20 Nun richtest du alle Objekte aus, ...21 ... passt die Größe der Form an, ...22 ... drückst F5 ...23 ... und überprüfst das Aussehen noch einmal.

So ähnlich wie in der Abbildung könnte deineOberfläche aussehen.

24 Damit das Kunstwerk nicht verloren geht,muss es gespeichert werden. Also klickst duauf die entsprechende Schaltfläche.

25 Es öffnet sich ein Dialogfenster, in dem du direinen Ordner für dein Projekt wählen kannst.

Das erste Programm


20

26 Als Dateiname gibst du WÜRFELN ein. DieForm wird unter dem Namen WÜRFELN.gespeichert – wie du siehst, heißt dieDateiendung für Visual Basic .FRM.

Während der Arbeit an einem Projekt sindPannen unvermeidlich – sei es, dass derComputer abstürzt, sei es, dass er sich nuraufhängt. So etwas ist meist mit Datenverlustverbunden. Daher rate ich dazu, ein Projektbei Arbeitsbeginn unter einem eigenen Namenzu speichern und während der Arbeit immerwieder mal die Schaltfläche für Speichern zuklicken. Auf diese Art wird der aktuelle Standgesichert.

ZufallBevor wir dem Spiel Leben einprogrammieren,wäre ein Exkurs über den Zufall einzufügen.Computer faszinieren immer wieder mit ihremsogenannten Zufallsgenerator – anscheinend sindsie in der Lage, zufällige Ereignisse zu erzeugen,sei es die Auswahl eines Buchstabens aus demAlfabet oder einer Zahl aus einer Zahlenreihe.Natürlich gibt es beim Computern keinewirklichen Zufälle – das sieht nur so aus.1. Du startest erneut Visual Basic. Das führt

dazu, dass du nun zwei Versionen desProgramms im Arbeitsspeicher hastFür diesen Versuch legen wir keinen Wert aufdie Namensgebung usw, da wir dasProgramm nicht speichern.

2. Du wählst STANDARD.EXE ...3. ... drückst im WERKZEUG-Fenster auf den

COMMANDBUTTON ...4. ... doppelklickst auf Command15. ... und setzt folgende Eigenschaften ein:

1. Sub Private Command1_Click()

2. Dim zufall As Single

3. zufall = Rnd

4. Print zufall

5. End Sub

Die Zeilen 3 – 4 sind Anweisungen, dieausgeführt werden, wenn auf die Befehls-schaltfläche geklickt wird.

• Zeile 2: Die Variable mit dem Namen ZUFALLwird als Variablentyp SINGLE deklariert.

• Zeile 3: Dieser Variablen wird der Wertzugewiesen, der sich aus der Funktion Rndergibt. Diese Funktion liefert einen Wertzwischen 0 und 0,999999 und weist ihn derVariablen ZUFALL zu..

• Zeile 4: Das Programm wird angewiesen, dieVariable zufall auf die Form zu schreiben.

Abgesehen davon, dass du mit den Zahlen nichtviel anfangen kannst, wirst du feststellen, dassbei jedem Neustart immer wieder dieselbenZahlen angezeigt werden – also war das dochnichts mit dem Zufall?! Der Grund ist einkomplizierter mathematischer Transformations-prozess. Prinzipiell benötigt die RND-Funktioneinen Startwert, der ohne Eingriff immer gleichist – daher die gleichen Zahlen. Ändert man denStartwert, wird die Sache interessanter.Mit der Anweisung Randomize wird jeweilsein neuer Startwert erzeugt. Setzt du hinter Zeile1 die Anweisung Randomize ein und startestdas Programm erneut, wirst du feststellen, dassdie Zahlenfolgen jetzt jedesmal anders aussehen.Die nächste Funktion, die wir benötigen, um zuanwendbaren Zufallszahlen zu kommen, ist Int.Vereinfacht ausgedrückt liefert diese Funktioneinen Wert, bei dem die Nachkommastellenabgeschnitten sind. Aus 0,1234567 wird durchInt(0,1234567) der Wert 0. Das würdezueiner ganzen Reihe von Nullen führen.Werden die erzeugten Zahlen aber z.B. mit 10multipliziert, dann verschiebt sich das Komma.Aus0,23*10 wird 2,3; durch Int(2,3) dann2. So bekommt man ganzzahlige Zahlen.Bei einem Würfel gibt es nur sechs möglicheZahlen. Also müsste es eine Formel geben, dieden Zahlenumfang berücksichtigt. Gibt es:zufall = Int(rnd * Obergrenze) +Untergrenze

• Zeile 3: zufall = Int(Rnd * 6) + 1

Jetzt klappt's! Wie gesagt, ein echterschicksalshafter Zufall ist das nicht, aber esscheint so.Beende dieses Visual Basic, ohne zu speichern,und aktiviere dein Würfelprogramm.

Programmcode


21

ProgrammcodeDer Spieler soll eine Zahl anklicken, worauf derComputer eine Zufallszahl wählt. In einerAuswertung werden die Zahlen verglichen, undes wird geprüft, ob ein Treffer vorliegt odernicht. Die Treffer und Nichttreffer werdenhochgezählt. Im Anzeigefeld wird angezeigt, obgetroffen wurde (gewonnen) oder nicht(verloren).Natürlich müssen Werte in Variablen gespeichertwerden, z.B. der vom Spieler gewählte Wert. Wirnennen die Variable RATEZAHL und den vomComputer erzeugten Wert ZUFALLSZAHL.Die RATEZAHL muss in jeder Prozedur immerwieder deklariert werden – sie bekommt nurjeweils einen anderen Wert. Das ist umständlich.Wenn eine Variable im gesamten Projekt gültigsein soll, deklariert man sie im Allgemeinteil, dervor den Prozeduren liegt. Für den Zahlenbereichdes Würfels genügt der Variablentyp BYTE.

Einige Worte zum Code: alles, was auf dennächsten Seiten im Codefenster eingegeben wird,ist Bestandteil des Gesamtcodes für unser Projekt.

Leerzeilen im Code drücken aus, dass hier eineneue Prozedur beginnt, notwendig sind sie abernicht.

Schaltflächen für den TippDu doppelklickst auf CMDEINS. Unmittelbar hatVirtual Basic folgende Zeilen eingesetzt – dieZeilen 3 und 5 geben den Rahmen für dieProzedur ab, die wirksam wird, wenn aufCMDEINS geklickt wird.:

1. Option Explicit

2.

3. Private Sub cmdEins_Click()

4.

5. End Sub

Der Textcursor blinkt in der Zeile 2. Hier gibstdu ein:

2. Dim Ratezahl As Byte

Der Code lautet jetzt also:1. Option Explicit



Nun machst du folgende Eingaben:4. Ratezahl = 1

In Zeile 4 wird der Variablen RATEZAHL derWert 1, entsprechend der Befehlsschaltflächezugewiesen.

5. lblAnzeige.Caption =Rate-zahl

Die Zeile 5 dient nur für Testzwecke und wirdspäter wieder gelöscht.

6. End Sub

Die Anweisung lautet: Gib der EigenschaftCAPTION des Objektes lblAnzeige den Wertaus der Variablen Ratezahl.Bevor du das Programm startest, programmierstdu noch die Zeilen 8 und 9, indem du vorher aufCMDZWEI doppelklickst. Im CODE-fenster öffnetsich die entsprechende Prozedur mit denüblichen vorgebenenen Zeilen:

7. Private Sub cmdZwei_Click()

und9. End Sub

Beim Cursor gibst du die Zeilen 8 und 9 ein:8. Ratezahl = 2

9. lblAnzeige.Caption =Ratezahl

Hierdurch ändert sich der Wert von end subnatürlichauf 10:

10. End Sub

Abschließend drückst du auf F5.Willst du nachprüfen, ob die Sache funktioniert,klickst du auf CMDEINS und CMDZWEI – inLBLANZEIGE müsste die Zahl 1 bzw. 2erscheinen.Die Zeilen 5 und 9 kannst du wieder löschen: dusetzt den Mauszeiger vor die zu löschende Zeile,markierst sie mit einem Klick und drückst aufENTF.Nun gibst du für alle Schaltflächen dieentsprechende Variable RATEZAHL ein – duwiederholst also die notwendigen Eingaben fürdie Buttons CMD3 bis CMD6, wobei du natürlichjeweils die Zahl des aktuellen Buttons einsetzt

Die Zufallszahl des Computers


22

Die Zufallszahl des ComputersDer Computer erhält die Aufgabe, nach einemWürfeln durch den Spieler selber eine Zahl zuwürfeln. So eine Prozedur hat Visual Basicnatürlich nicht in seinem Programm – alsomüssen wir sie selbst anlegen unter dem NamenCOMPUTER. Diese Prozedur wird mehrmalsverwendet – also setzt du im Allgemeinteil amAnfang unseres Code, nach der Zeile

dim Ratezahl As Byte,

folgende Zeile ein.Dim Zufallszahl As Byte

Dann gibst du am Ende des CODE-Fensters1. Private sub Computer

ein, den Rest erledigt Visual Basic, worauf derTextcursor in der nächsten Leerzeile steht.Der Computer soll in dieser Prozedur seine Zahlerzeugen und der Variablen ZUFALLSZAHLzuweisen. In Zeile 2 setzt du die AnweisungRandomize ein, und in Zeile 3 wird die auf Seite20 geübte Funktion für die Zufallszahleingetragen – das Ergebnis ist:

2. Randomize

3. Zufallszahl Int(Rnd * 6)+1

4.End Sub (vom Programm vorgegeben)Um zu sehen, was der Computer erzeugt, kannstdu zwischen Zeile 3 und 4 eine Leerzeileeinfügen und folgendes eintragen:

LblAnzeige.Caption=Zufallszahl

Dann drückst du auf F5.Was nun? Nichts passiert. Das ist ein gutesBeispiel für die objektorientierteProgrammierweise von Visual Basic: solange dieProzedur COMPUTER nicht aufgerufen wird,schlummert sie nur still vor sich hin.Zum Glück ist es ganz einfach, die Prozedur zumLeben zu erwecken. Man ruft sie mit ihremNamen auf. Der Computer soll seine Zahlerzeugen, wenn der Spieler eine Zahl mit derBefehlsschaltfläche gewählt hat; also gehört derAufruf in die jeweiligen Click-Prozeduren.

Der Code sieht so aus:1. Private Sub cmdFünf_Click()

2. Ratezahl = 5

3. computer

4. End Sub

Dieses Beispielprogramm zeigt dir das Listingfür die Prozedur CMDFÜNF_CLICK.Die zwischen Zeile 3 und Zeile 4 eingefügte An-weisung in der Prozedur Computer kannst dunun wieder löschen.Wenn du das alles erledigt hast, können wir unsGedanken darüber machen, wie ein ComputerWerte miteinander vergleicht. Hast du in derSchule im Matheunterricht aufgepasst, ist dieSache nicht besonders kompliziert. Man brauchtnur die mathematischen Zeichen '=', '<' '>' und'<>', also gleich, kleiner als, größer als undungleich. Visual Basic kann damit umgehen –wie, das soll uns hier nicht weiter interessieren.Die Prozedur Auswertung anlegenIm Abschnitt „Kontrollstrukturen“ auf Seite 27wird ausführlich über Möglichkeiten derKontrolle des Programablaufs eingegangen. Hiergenügt ein kurzer Abriss, damit das Programmvervollständigt werden kann.In der Prozedur AUSWERTUNG wird derComputer angewiesen, zu überprüfen, ob 'seine'Zahl mit der Spielerzahl übereinstimmt odernicht – computerisch ausgedrückt: wennZufallszahl = Ratezahl, dann gewonnen, sonstverloren. Eingeenglischt heißt das: If Zufallszahl= Ratezahl, then gewonnen, else verloren;abgekürzt:

If Zufallszahl = Ratezahl Thengewonnen

If Zufallszahl <> RatezahlThen verloren

Diese Schreibweise würde genügen, kann aberübersichtlicher geschrieben werden:

If Zufallszahl = Ratezahl Then

Gewonnen

Else

Verloren

End If



23

Gewonnen und verloren sind Variablen, in denendie Treffer hochgezählt werden sollen. Esmüssen also erst einmal die Variablen deklariertwerden.Hier taucht allerdings ein Problem auf: VisualBasic setzt den Wert der Variablen bei jedemAufruf der Prozedur wieder auf Null. Wirwürden also nicht hochzählen können. Es gibtfür dieses Problem das Schlüsselwort Static.Eine mit Static deklarierte Variable behältihren aktuellen Wert so lange, bis das Programmneu gestartet wird.Zeile 2 und Zeile 3 in der folgenden Prozedurzeigen, wie die beiden Variablen deklariertwerden.

1. Private Sub Auswertung()

2. Static gewonnen As Byte

3. Static verloren As Byte

4. If Zufallszahl = Ratezahl then

5. gewonnen = gewonnen + 1

6. lblAnzeige.Caption =

"Gewonnen!"

7. lblGewonnen.Caption = gewonnen

8. Else

9. verloren = verloren + 1

10. lblAnzeige.Caption = Verloren!"

11. lblVerloren.Caption = verloren

12. End If

13. End Sub

Etwas merkwürdig kommt dir sicherlich derCode in Zeile 5 und in Zeile 9 vor. DasGleichheitszeichen ist kein mathematischesZeichen, sondern ein Zuweisungszeichen. DerVariablen GEWONNEN wird ein Wertzugewiesen. In diesem Fall ist das derursprüngliche Wert der Variablen, um 1 erhöht (+ 1). Der Startwert der Variablen ist 0; demursprünglichen Wert 0 wird der um 1 erhöhteWert zugewiesen – und das ist 0 + 1. Beimnächsten Mal wird der alte Wert 1 wiederum um1 erhöht. So wird dem Computer das Zählenbeigebracht. Den Wert der Variablen zeigen wir

mit Zeile 7 bzw. Zeile 11 in den entsprechendenAnzeigefeldern mit der Eigenschaft CAPTION an.Zeile 6 und Zeile 10 zeigen die Zeichenkettenzwischen den Anführungszeichen an.Abschließend drückst du wie gewohnt F5 – undvergiss bitte nicht, das Spiel zu speichern.

Die Anzeige der AugenzahlGrundsätzlich kann unser Spiel jetzt laufen. DieAugenzahl-Anzeige im Bildfeld haben wir zwarnoch nicht, du kannst aber immerhin schonspielen. Allerdings ist es vorläufig noch eingeheimnis, welche Zahl der Computer gewürfelthat. Das könnte man in einem Anzeigefelddarstellen, aber wozu haben wir das Bildfeld?!Bisher zeigt der Würfel sieben Augen. Das siebteAuge in der Mitte brauchst du für die Eins, dieDrei und die Fünf. Damit vor dem Würfeln desComputers eine Starteinstellung zu sehen ist,muss für eine Sechs das SHAPE7 verschwinden – es darf aber nicht gelöscht werden, denn es wirdja gebraucht. Also muss es unsichtbar werden.1. Du klickst SHAPE7 an ...2. ... und drückst STRG + UMSCHALT + V Im EIGENSCHAFTEN-Fenster ist die

Eigenschaft VISIBLE –also sichtbar –markiert. Der Wert ist TRUE, also Wahr. DasObjekt ist sichtbar.

3. Nun stellst du den Wert um aufVisible = False ...

4. ... und drückst auf F5Es sollte jetzt eine Sechs erscheinen.Achte darauf, dass du die Eigenschaft für dasSHAPE veränderst und nicht versehentlich einanderes Objekt, z.B. die FORM, aktiviert hast.Oben im EIGENSCHAFTEN-Fenster steht in derAnzeige, welches Objekt gerade 'dran' ist. Eskann dir sonst passieren, dass plötzlich die Formunsichtbar gemacht wird.Du ahnst sicher schon, wie es weitergeht. Eswird für jede Augenanzeige das jeweilige Shapeunsichtbar gesetzt. Da kommt einige Tipparbeitauf dich zu, aber über BEARBEITEN | KOPIERENund BEARBEITEN | EINFÜGEN kannst du denArbeitsaufwand verkürzen.



24

Du legst die Prozeduren 1-6 mit der folgendenProzedur an:

1.Private Sub Eins()

2. Shape1.Visible = False






8. Shape7.Visible = True

9.End Sub

Diese Prozedur zeigt dir, dass bis auf SHAPE7alle Shapes auf unsichtbar gesetzt sind, so dassbeim Aufruf von PROZEDUR EINS nur dasmittlere Auge sichtbar sein dürfte. Um das zuüberprüfen, legen wir eine Befehlsschaltflächean, doppelklicken auf sie und versehen sie mitfolgender Prozedur:

Private Sub Command1_Click()

Eins

End Sub

In diese Test-Prozedur trägst du den Aufruf derProzedur Eins ein, dann drückst du auf F5 undklickst auf die Befehlsschaltfläche. Eigentlichmüsste jetzt die Augenzahl Eins auf dem Würfelzu sehen sein. Stimmt’s?Wie du dich vielleicht erinnerst, hatte ich daraufhingewiesen, dass es wichtig ist, die richtigeReihenfolge der Shapes einzuhalten. Hast dualles beachtet, dürfte es keine Probleme geben.1. Du markierst den Code in der Prozedur Eins –

und zwar nur den Code, also die Zeilen 2-8 inder Prozedur oben auf der Seite!

2. Dann drückst du STRG + C, wodurch dermarkierte Teil kopiert wird, ...

3. setzt den Cursor in die Leerzeile in ProzedurZwei ...

4. und drückst STRG + V

Die Sache sieht so aus:Private Sub Zwei()

Shape1.Visible = True

Shape2.Visible = False




Shape6.Visible = True


End Sub

Es müssen die beiden Augen links oben undrechts unten, also Shape1 und Shape6 sichtbar(Visible = True), alle anderen unsichtbarsein. Die Eins im Code wird durch Zwei ersetzt.Dann drückst du auf F5 und klickst dieBefehlsschaltfläche an. Es sollten zwei Augen zusehen sein.So machst du das jetzt für jede Augenzahl – undtestest immer wieder mit der Prozedur auf Seite22:

If Zufallszahl = Ratezahl Then

Gewonnen

Else

Verloren

End If

Wenn du für alle Prozeduren den Codegeschrieben hast, löscht du die ProzedurCommand1_Click. Nun fehlt nur noch die Anbindung andiese Prozeduren. Der Compter erzeugt eine Zahlund diese Zahl soll an die Augenanzeige-Prozeduren weitergeleitet werden, d.h. mitWenn-Dann müssten wir weiterkommen. WennZufallszahl = 1, dann Prozedur Eins usw. Es gibtnatürlich verschiedene Wege, so ein Problem zulösen, aber für diesen Zweck ist der Weg derWenn-Dann (If-Then)-Entscheidung derübersichtlichste.

Prozedur Würfelanzeige anlegen


25

Prozedur Würfelanzeige anlegenAls nächstes definieren wir die ProzedurWÜRFELANZEIGE mit folgender Prozedur:

Private Sub Würfelanzeige()

If Zufallszahl =1 Then Eins

If Zufallszahl =2 Then Zwei

If Zufallszahl =3 Then Drei

If Zufallszahl =4 Then Vier

If Zufallszahl =5 Then Fünf

If Zufallszahl =6 ThenSechs

End Sub

Diese Prozedur leuchtet unmittelbar ein – esmuss diese Prozedur nur noch aufrufen.Willst du die optimale Platzierung für denProzeduraufruf finden, gehst du gedanklich dasProgramm durch und prüfst, was in welcherReihenfolge erfolgt. Wird auf eine Zahl-Schaltfläche geklickt, wird das Click-Ereignisausgelöst. Darin wird die Variable gespeichertund zur Computer-Prozedur verzweigt, in derwiederum eine Zufallszahl erzeugt wird. Es istsinnvoll, die Würfelanzeige hier aufzurufen. DerWürfel wird angezeigt, der Computer kehrt zurProzedur zurück und verzweigt zurAUSWERTUNG. Die wird logischerweise dortvorgenommen und das Ergebnis angezeigt.Damit ist dieser Teil abgearbeitet, und dasProgramm wartet auf eine erneute Eingabe. Dannbeginnt das gleiche Spiel noch einmal – bis duauf die Schließen-Schaltfläche klickst.1. Private Sub computer()

2. Randomize3. Zufallszahl = Int(Rnd * 6)+1

4. Würfelanzeige

5. Auswertung

6. End Sub

Zeile 4 und Zeile 5 in dieser Prozedur rufen diejeweilig aktuellen Prozeduren auf. Dieses Unter-teilen eines Programms in viele kleine Prozedu-ren hat den großen Vorteil, dass bei Änderungenimmer nur ein kleines Häppchen durchsucht undgeändert werden muss. Du hast gesehen, dass eskein Problem ist, eine selbstdefinierte Prozeduranzulegen und in eine Ereignisprozedur

einzufügen. Willst du eine Prozedur zuTestzwecken kurzfristig abschalten, brauchst dunur ein sogenanntes Kommentarzeichen davor zusetzen. Das Apostroph ist ein solchesKommentarzeichen. So veranlasst z.B.'Auswertung Visual Basic, den Aufruf zuüberlesen. Ein Kommentarzeichen wird – wie derName schon sagt – für Kommentare in einemProgramm eingesetzt.

Du fragst dich, wozu Kommentare gut sind? Ichgarantiere dir, dass du nach einigen Monaten beideinen Programmen nicht immer mehr genauweißt, welchen Sinn eine bestimmteProgrammieridee hatte. Wenn du das Programmmit Kommentaren versehen hast, hast du deineeigenen Hinweise als Gedächtnisstütze.

Möglich wäre auch, dass du ein Programmnachträglich um irgendeine Prozedur ergänzenwillst.

Sehen wir uns ein Beispiel für eine solcheKommentarzeile an:1. Option Explicit


3. Dim Zufallszahl As Byte

4. 'MessageBox bei Spielende


6. Ratezahl = 1

…

Zeile 4 in dieser Prozedur ist eineKommentarzeile, die ich mittendrin angelegthabe, als mir die Idee kam, dass man vorBeenden des Programms noch eineSicherheitsabfrage einbauen könnte. Damit ich esnicht vergesse, habe ich diese Kommentarzeileeingefügt. Wenn die Angelegenheit erledigt ist,wird sie einfach gelöscht.Wenn du fremde Programme liest, kannst du oftnicht nachvollziehen, was der Entwickler desProgramms beabsichtigt hat, denn du weißt ja,dass es bei Visual Basic oft mehrereLösungsmöglichkeiten für ein Problem gibt. Insolchen Fällen helfen Kommentare dem Lesersehr gut weiter. Kommentarzeilen sind meistgrüneingefärbt, so dass sie schnell zu erkennen sind.

Mitteilungsfenster (Messagebox)


26

Mitteilungsfenster (Messagebox)Visual Basic stellt dir einfach zuprogrammierende Dialogfelder zur Verfügung,die du in gewissen Grenzen nach deinenWünschen ausgestalten kannst.1. Du erstellst eine provisorische

Befehlsschaltfläche und doppelklickst auf sie2. Im Codefenster gibst du folgende Prozedur

ein: Private Sub Command1_Click()

MsgBox "Ich werde benach- richtigt!"

End Sub

3. Dann doppelklickst du auf dieBefehlsschaltfläche,...

4. ... fügst die Zeile 2 des obigen Programmmsein, ...

5. ... drückst auf F5 ...6. und klickst auf die Schaltfläche.

Die Abbildung zeigt dir das Ergebnis der kleinenZeile in der obigen Prozedur. Dieses Fensterwird selbständig von Windows und nicht etwavon nicht von Visual Basic angelegt. SeinePlatzierung kannst du nicht beeinflussen, undauch die Ausgestaltung bleibt bis auf wenigeAusnahmen Windows überlassen. Aber ganz sohilflos bist du natürlich nicht.Die MessageBox hat eine Titelleiste, die, falls dunichts anderes angibst, den Namen des Projektsanzeigt. Es gibt Platz für eine Nachricht, undoffensichtlich gibt es die Möglichkeit,Befehlsschaltflächen zu verwenden.

Du schließt das Mitteilungsfenster mit einemKlick auf OK,, worauf das Mitteilungsfenstergeschlossen wird und das Programm wartet, alswäre nichts geschehen.

Dir ist sicher schon öfter aufgefallen, dasssogenannte QuickInfos eingeblendet werden,wenn du den Mauszeiger auf ein Objekt bewegst,z.B. im WERKZEUG-Fenster, aber auch beimCode-Schreiben. Visual Basic will dir helfen,indem das Programm häufig eine Auswahllistealler denkbaren Möglichkeiten einblendet.Schreibst du Dim Variable As, blendetVisual Basic eine Liste ein, die du mit der ➪ -Taste ansteuern kannst. Tippst du z.B. den erstenBuchstaben von INTEGER ein, zeigt dir VisualBasic die Liste ab dem Buchstaben i. Hast du denWert ausgewählt, kannst du ihn mit derLEERTASTE einfügen.

Schreibst du den Begriff MSGBOX, siehst du einelängere Zeile, die anzeigt, was alles in einerMSGBOX eingetragen werden kann. Häufig sinddiese QuickInfos verwirrend, manchmal abersehr hilfreich, vor allem, wenn es um die richtigeReihenfolge der Parameter geht.Message-BoxTyp Beschreibung0 SCHALTFLÄCHE OK1 SCHALTFLÄCHEN OK, ABBRECHEN

2 SCHALTFLÄCHEN BEENDEN,WIEDERHOLEN, IGNORIEREN

3 SCHALTFLÄCHEN JA, NEIN, ABBRECHEN

4 SCHALTFLÄCHEN JA, NEIN

5 SCHALTFLÄCHEN WIEDERHOLEN,ABBRECHEN

16 STOP-SYMBOL

32 FRAGEZEICHEN-SYMBOL

48 AUSRUFEZEICHEN-SYMBOL

64 INFO-SYMBOL

Die übliche Reihenfolge der Parameter istMELDUNG, TYP, TITEL. Die Meldung odermeinetwegen auch Nachricht ist das, was demAnwender mitgeteilt werden soll, der Typ ist ausder Tabelle zu entnehmen und der Titel wird inder Titelleiste des Meldungsfensters angezeigt.

Mitteilungsfenster (Messagebox)


27

Sehen wir uns das an einer vorläufigen Prozeduran, indem wir auf COMMAND1 doppelklickenund folgenden Code einfügen:

1. Dim Titel As String

2. Dim Meldung As String

3. Titel = "Nachfrage"

4. Meldung = "Willst du dasSpiel wirklich beenden?"

5. MsgBox Meldung, 3 + 32,Titel

In dieser Prozedur werden zuerst die Variablenals Zeichenketten oder STRINGS deklariert, dannden Variablen die Werte zugewiesen und in Zeile5 die MSGBOX-Anweisung mit dem Typ 3 derTypentabelle formuliert. Dadurch werden dieBefehlsschaltflächen Ja, Nein und Abbrechendargestellt.Zum gewählten Typ für die Darstellung derBefehlsschaltflächen kann noch der Typenwertfür Symbole addiert werden. Der Wert 3 + 32kann als Summe angegeben werden (35) oderauch als Term und zeigt die BefehlsschaltflächenJA, NEIN und ABBRECHEN sowie einFragezeichen an. So eine Kombination eignetsich selbstverständlich, um auf eine Fragehinzuweisen. So weit klappt ja alles, aber esmuss auch darauf reagiert werden, wenn eineSchaltfläche angeklickt wird. Die Click-Ereignisse für Message-Boxes sind vordefiniert,siehe Tabelle. Der entsprechende Wert wird ineiner Variablen gespeichert und abgefragt.Typ Beschreibung1 OK wurde angeklickt2 Abbrechen wurde angeklickt oder

[ESC]3 Abbrechen wurde angeklickt4 Wiederholen wurde angeklickt5 Ignorieren wurde angeklickt6 Ja wurde angeklickt7 Nein wurde angeklickt

Für diesen Zweck wird die Message-Box alsFunktion eingesetzt. Es wird also nicht nur eineMitteilung gemacht (Message-Box alsAnweisung), sondern eine Weiterverarbeitungder Klicks vorgenommen.

Du löschst die Befehlsschaltfläche sowie diegesamte eben formulierte ProzedurWeiter geht es mit einem Doppelklick aufcmdSchließen.Der einzugebende Code lautet:

1. Private SubcmdSchließen_Click()

2. Dim Meldung As String

3. Dim Titel As String

4. Dim Typ As Byte

5. Dim Schaltfläche As Byte

6. Meldung = " Willst du dasSpiel wirklich beenden?"

7. Titel = "Sicherheitsanfrage"

8. Typ = 3 + 32 + 0

9. Schaltfläche =MsgBox(Meldung, Typ, Titel)

10. If Schaltfläche = 6 Then

11. End

12. ElseIf Schaltfläche = 7Then

13. MsgBox "Dann ebennicht!", vbOKOnly

14. End If

15. End Sub

Innerhalb der Prozedur CMDSCHLIEßEN muss dieAbfrage eingerichtet werden. Nachdem dieVariablen deklariert wurden und der Typfestgelegt ist, wird der Variablen SCHALTFLÄCHEin Zeile 9 der Wert der Message-Box übergeben.In Zeile 10–13 werden die Schaltflächen-Klicksausgewertet, wobei in Zeile 12 eine weitereMessage-Box als Anweisung eingefügt ist. Eswurde anstatt des Wertes 0 für den Typ(SCHALTFLÄCHE OK) eine Visual Basic-Konstante eingesetzt. Davon gibt es eine ganzeMenge, die genauso wie der Zahlenwertverwendet werden können. Auch für diejenigen,die kein Englisch können, ist die Konstantemanchmal verständlicher als der reineZahlenwert

Kontrollstrukturen


28

KontrollstrukturenIn jedem Programm müssen irgendwannEntscheidungen getroffen oder Programmabläufewiederholt werden. Für solche Operationen stelltVisual Basic eine ganze Reihe vonLösungsmöglichkeiten zur Verfügung, für jedenbesonderen Zweck.GOTOAus dem Wort ergibt sich schon der Sinn dieserAnweisung: Gehe zu. Dieser Befehl ist eineunbedingte Anweisung. Er stammt noch ausalten Basic-Zeiten, als Programme mitZeilennummern versehen waren. Goto 210bedeutetet: gehe zu Zeile 210 und mache dortweiter. Heute wird dieser Befehl nur noch seltenverwendet, meistens bei der Fehlerbearbeitung.Fehlerbehandlung ist in sehr vielen Prozedurenangebracht. Dringend erforderlich ist sie, wennBenutzereingaben vorkommen, dennEingabefehler sind nicht selten. Sehen wir unsdas an einem Beispiel an:1. Private Sub

IrgendeineProzedur()2. On Error Goto

Fehlerbehandlung3. Dim ....4. Code5. ...6. ...7. Exit Sub8. Fehlerbehandlung:9. Dim Fehler As String10. Fehler = "Es ist ein

Fehler aufgetreten!" +Chr$(13) + Chr$(10)

11. Fehler = Fehler +"Fehlernummer: " +Str(Err.Number) + Chr$(13) +Chr$(10)

12. Fehler = Fehler + "Text:" + Err.Description

13. MsgBox Fehler14. End Sub

On Error Goto FehlerbehandlungInnerhalb einer Prozedur wird eine Sprungmarkegesetzt. Du gibst ihr einen Namen und setzteinen Doppelpunkt dahinter.Fehlerbehandlung:Danach folgen die Anweisungen, die beiAuftreten eines Fehlers ausgeführt werdensollen. Meistens wird eine MessageBox mit demermittelten Fehler ausgegeben. In einem unsererProgramme wird eine Fehlerbehandlungsroutineprogrammiert.Fehlercode(Err.Number)

Beschreibung(Err. Description)

5 Unzulässiger Prozeduraufruf

7 nicht genügend Speicher

13 Typen unverträglich

53 Datei nicht gefunden

55 Datei bereits geöffnet

76 Pfad nicht gefunden

321 Ungültiges Dateiformat

31037 Fehler beim Laden einer Datei

Nach Aufruf der Prozedur 'merkt' sich VisualBasic, dass eine Fehlerroutine angelegt ist,(Zeile 2: bei Fehler gehe zu Fehlerbehandlung)und fährt mit dem Bearbeiten des Codes fort.Tritt kein Problem auf, wird in Zeile 7 mit derAnweisung EXIT SUB – Verlasse die Prozedur –die Prozedur beendet. Tritt ein Fehler auf, wirdzur Sprungmarke gesprungen und derFehlerbehandlungsteil abgearbeitet. In diesemFall wird in einem Mitteilungsfenster der Fehlerbeschrieben, wobei man wissen muss, dass esunzählige Fehlernummern mit denentsprechenden Beschreibungen gibt, für jedenSonderfall eine eigene Fehlernummer.Ab Zeile 10 wird die Ausgabe für dasMitteilungsfenster geschrieben. Näheres dazufindest du im Abschnitt Mitteilungsfenster aufSeite 26.

Entscheidungen


29

EntscheidungenIm einfachsten Fall ist eine Entscheidung eineJa/Nein-Entscheidung. "Willst du das Programmfortsetzen? Ja, Nein?". Wenn Nein, dann Endedes Programms, wenn ja, dann Neustart.If-StrukturenWenn mehrere Auswahlmöglichkeiten zurEntscheidung anstehen, wird meistens dieIF/THEN-Struktur verwendet. Die einfachsteAnwendung ist die Form

If Bedingung Then Anweisung

Sehen wir uns das genauer an. Die Bedingungkann ein Vergleich sein, etwa:

If A = 13 ThenHintergrundfarbe = rot

Trifft die Bedingung zu, ist also wahr, wird dieAnweisung ausgeführt, sonst nicht. Du kannstaber auch anweisen, was sonst geschehen soll:

If A = 13 Then Hintergrundfarbe = rotElse Hintergrundfarbe = grünEnd If

Trifft die Bedingung zu, wird dieHintergrundfarbe rot werden, sonst (Else) wirdsie grün.Auch bei einfachen Entscheidungen bietet sichdie Blockstruktur an. Sie ist übersichtlicher.Vielfach besteht die Wahl zwischen mehrerenBedingungen. Natürlich kann für jede Bedingungeine IF/THEN-Abfrage geschrieben werden, aberes geht einfacher. Die Abfrage wird um ELSEIFerweitert, was soviel heisst wie SonstWenn.Wenn A = 13 ist, dann Hintergrundfarbe = rot,sonst wenn A = 20 ist, dann Hintergrundfarbe =blau, sonst wenn A = 30 ist, dann Hintergrund-farbe = gelb, sonst, wenn keine Bedingungzutrifft, dann Hintergrundfarbe = grün:

If A = 13 Then Hintergrundfarbe = rotElseIf A = 20 Then Hintergrundfarbe = blauElseIf A = 30 Then Hintergrundfarbe = gelbElse Hintergrundfarbe = grünEnd If

Ein beliebter Fehler ist, die Anweisung End Ifam Ende der Struktur zu vergessen. Visual Basicweist dich mit einer Fehlermeldung darauf hin.Select/Case-StrukturEine Variable kann unterschiedliche Wertehaben. Soll die Variable auf ihren Wert geprüftwerden, welchen Wert sie hat, setzt man dieSELECT/CASE-Anweisung ein. SELECT bedeutetAuswahl und CASE im Fall. Durchsuchst du z.B.eine Adressenliste nach Namen, wird in derSELECT/CASE-Anweisung jede Eingabe in einTextfeld und jede Auswahl aus einer Listegeprüft. Trifft eine Auswahl zu, wird dieAnweisung nach der Auswahl ausgeführt,andernfalls wird ähnlich wie bei IF/THEN dieCASE ELSE-Anweisung aktiviert.

Select Case Name Case "Erwin„ Bezeichnungsfeld.Caption ="Erwin ist mein Freund." Case "Ursula" Bezeichnungsfeld.Caption ="Ich mag Ursula nicht. Die istzickig!" Case "Torsten" Bezeichnungsfeld.Caption ="Torsten ist ein guterFussballspieler." Case Else Bezeichnungsfeld.Caption ="Ich habe leider keineFreunde."End Select

Es können Zahlen und Zahlenbereiche geprüftwerden. Visual Basic prüft, ob ein Zahlenwertkleiner als 5 oder größer als 5 ist.Einen Zahlenbereich zwischen 50 und 90 prüftman mit der Anweisung Case 50 To 90.Select Case Zahlenwert Case < 5'Visual Basic setzt automatischCase Is < 5 ein Print "Das ist sehr wenig!" Case > 5'Visual Basic setzt automatischCase Is > 5 ein Print "Das ist etwas mehr!" Case Else Print "Das ist Nichts!"End Select

Schleifen


30

SchleifenHäufig müssen Anweisungen mehrmalsausgeführt werden, z.B. wenn eine Liste nacheinem Suchbegriff durchsucht werden muss.Visual Basic hat mehrere Möglichkeiten, umsolche Abläufe zu automatisieren.Der Aufbau einer Schleife sieht so aus: es wirdmit Startwerten begonnen, dann werden dienotwendigen Anweisungen ausgeführt, und dieSchleife beginnt wieder von vorn. Visual Basicmuss nur wissen, wo die Schleife beginnt, wo sieendet und wann sie beendet werden soll.For-Next-SchleifeDie Schleife wird mit dem Schlüsselwort Foreingeleitet und mit Next beendet.

For Zähler = Startwert ToEndwert Step Schrittweite

Anweisungen

Next

(Die ersten beiden Zeilen gehören in eine Zeile.)Als Zähler wird eine Variable eingesetzt, in derdie Anzahl der Durchläufe der Schleifegespeichert werden. Es hat sich eingebürgert,dafür den Buchstaben i zu verwenden. Du kannstaber auch jede andere Bezeichnung benutzen.

For i 1 To 10 Step 2

Print i, „Visual Basic“

Next

Dieser Code gibt die Anweisung, mit dem Wert 1zu beginnen und mit 10 zu enden. Dabei wird dieSchrittweite 2 gezählt, also 1, 3, 5, 9, 11.Führst du diese Prozedur aus, setzt Visual Basiceine Liste auf den Bildschirm, die folgendePunkte enthält:

1 VISUAL BASIC

3 VISUAL BASIC

5 VISUAL BASIC

7 VISUAL BASIC

9 VISUAL BASIC

Da 11 größer ist als 10, wird die Schleife bei 9beendet. Dabei besagt diese Anweisungfolgendes: schreibe den Wert I und dieZeichenkette VISUAL BASIC auf den Bildschirm.Die Prozedur kommt beim Schlüsselwort Next

an, was bewirkt, dass Visual Basic wieder an denAnfang der Schleife springt und dort prüft, obder Endwert schon erreicht ist, um dieAnweisungen gegebenenfalls nochmalsauszuführen. Wird keine Schrittweite angegeben,zählt das Programm ganz normal hoch.Soll rückwärts gezählt werden, ist eineSchrittweite -1 nötig

For i = 10 To 0 Step -1

Print i „Visual Basic“

Next

Für den Startwert und den Endwert können auchVariablen benutzt oder berechnete numerischeWerte eingesetzt werden. Eine Variable wie

For Zählen = 3 * Wert + 20 To100/10

ist ziemlich unsinnig, aber möglich.While-Wend-SchleifenFOR-NEXT-Schleifen haben einen Nachteil: manmuss vorher wissen, wie oft die Schleifedurchlaufen werden soll. Mit einer WHILE-WEND-Schleife kann man das Schleifenende voneiner Bedingung abhängig machen. Ist dieBedingung erfüllt, wird die Schleife verlassen.

While Bedingung

Anweisungen

Wend

WHILE heisst so viel wie während, also solange.Solange die Bedingung erfüllt ist, werden dieAnweisungen ausgeführt.

While

I < 10

Print i

i = i + 1

Wend

In dieser Prozedur hat die Variable i den Wert 0.Zu Beginn der Schleife wird geprüft, ob dieVariable kleiner als 10 (I < 10) ist. Wenn ja, d.h.wenn die Aussage wahr ist, dann wird igeschrieben und der Wert um 1 erhöht. Mit derAnweisung WEND, also zurückkehren, wirdwieder an den Anfang der Schleife gesprungenund erneut geprüft. Diese Schleife ist etwas ausder Mode gekommen, weil es heuteleistungsfähigere Exemplare dieser Art gibt.

Schleifen


31

Do-Loop-SchleifenWährend man die FOR-NEXT-Schleife alsZählschleife bezeichnet, kann die DO-LOOP-Schleife als Bedingungsschleife bezeichnetwerden. Die Bedingungen können am Ende oderauch am Anfang der Schleife getestet werden.

1. Do While Bedingung

2. Do Until Bedingung

Anweisungen

Loop

Beim Testen der Abbruchbedingung hat man dieMöglichkeit, entweder Zeile 1 oder Zeile 2einzusetzen, je nachdem, welchen Zweck manerreichen will. Do While bedeutet, dass dieSchleife so lange ausgeführt wird, wie dieBedingung erfüllt ist. Do Until bedeutet, dassdie Schleife so lange ausgeführt, bis dieBedingung erfüllt ist. Ob du die While- oderUntil-Version bevorzugst, ist Geschmackssache.Es muss immer nur die Bedingung entsprechendgeschrieben sein.

Do

Anweisungen

1. Loop While Bedingung

Loop Until Bedingung

Ob du allerdings am Ende oder am Anfang einerSchleife testest, ist nicht egal, denn der Test amEnde einer Schleife bedeutet, dass die Schleifeerst einmal durchlaufen werden muss.Wenn in einer Datei ein Name gesucht werdensoll, ist es natürlich sinnvoll, den Abbruch zuBeginn zu testen, denn wenn der Name gar nichtvorhanden ist, sucht die Prozedur endlos weiter.Irgendwann hängt sie sich dann auf.

Do Until „Klaus“ OrDateiende

Eingaben in ein Textfeld

Loop

Diese Schleife wird durchlaufen, bis entweder‘Klaus’ gefunden wird oder das Dateiendeerreicht ist.

Wichtig ist, dass du dir immer ganz klar über denSchleifenablauf bist, damit keine unliebsamenÜberraschungen passieren – entweder dass dieSchleife gar nicht durchlaufen wird, weil dieAbbruchbedingungen schon vorher erfüllt sind,oder dass die Schleife nie aufhört, weil dieAbbruchbedingung nicht erreicht wird.

Dateiverwaltung


32

DateiverwaltungIm Abschnitt Grafik auf Seite 40 werdenDateiverwaltungs-Operationen verwendet. Eswerden Daten gespeichert, bzw. geladen. ImRahmen dieses Heftes kann nicht auf den sehrumfangreichen Bereich der Dateiverwaltungeingegangen werden. Es soll nur das Öffnen undSchließen einer Datei beschrieben werden.Grundsätzlich gibt es die Schritte:OPEN-ANWEISUNG

eine Datei wird geöffnet

INPUT-ANWEISUNG

Daten werden gelesen

PRINT-ANWEISUNG

Daten werden geschrieben

CLOSE-ANWEISUNG

eine Datei wirdgeschlossen

Datei lesenEs können gleichzeitig mehrere Dateien geöffnetsein. Daher bekommt jede Datei eine Nummer.Nun kannst du dir die Nummern merken oderVisual Basic nach der jeweils freien Nummersuchen lassen. In Zeile 4 der folgenden Prozedursteht die Anweisung für Visual Basic, nach derfreien Nummer zu suchen:

DateiNr = FreeFile.In der Variablen Dateiname wird der Pfad zu derDatei gespeichert. Je nachdem, wo du die Dateiablegst, musst du den Pfad ändern. Ist keineDatei vorhanden, erfolgt eine Fehlermeldung.

Private Sub cmdÖffnen_Click()1. Dim DateiNr As Integer2. Dim DateiName As String3. Dim Temp As String4. DateiNr = FreeFile5. DateiName = "C:\Zahlen.txt"6. Open DateiName For Input AsDateiNr7. Input #DateiNr, a, b, c8. txtZahl1.Text = a9. txtZahl2.Text = b10. txtZahl3.Text = c11. CloseEnd Sub

In Zeile 6 wird die Datei zum Lesen geöffnet.Wer etwas Englisch kann, versteht die

Anweisung sofort. Eingedeutscht heißt das:Öffne die Datei mit dem beschriebenenDateinamen zum Lesen mit der nächsten freienDateinummer.In Zeile 7 werden die in den Variablen A, B undC abgelegten Daten eingelesen und in den Text-feldern hezeigt. In Zeile 11 wird die Datei wiedergeschlossen – vergiss nicht den CLOSE-Befehl!Hier haben wir definierte Variablen verwendet.Ist die Größe einer Datei nicht bekannt, muss dasProgramm sie bis zu ihrem Ende lesen.Die Anweisung dafür lautet wie folgt:

1. Do While Not EOF(DateiNr)2. Line Input #DateiNr, Temp3. Text1.Text = Text1.Text &

Temp & vbCrLf4. Loop

In einer Do-Schleife wird die Datei so langegelesen, wie EOF (End Of File = Ende der Da-tei) nicht erreicht ist. Dann werden die einzelnenZeilen der Datei mit der Anweisung LINE INPUTgelesen und in einer Zwischenvariablen TEMPgespeichert. In Zeile 3 wird in einem Textfeldjede einzelne Zeile dargestellt und mit einemSteuerzeichen für den Zeilenabschluss versehen.Das entspricht einer EINGABE nach jeder Zeileund ist eine Konstante für die AnweisungenCHR(10) & CHR(13), die wir auf Seite 38verwenden.

Datei speichernIn Zeile 5 der folgenden Prozedur wird diebenannte Datei zum Speichern bzw. Schreibengeöffnet. Die Dateinummer wurde mit FREEFILEermittelt. In Zeile 6 folgen dem SchreibbefehlPRINT nach der Dateinummer die Variablen,wonach die Datei geschlossen wird. Das ist – wiegesagt – nur ein ganz kleiner Abriss zurDateiverwaltung. Für mehr ist leider kein Platz.

Private Sub cmdSpeichern_Click()1. Dim DateiNr As Integer2. Dim DateiName As String3. DateiName = "C:\Zahlen.txt"4. DateiNr = FreeFile5. Open DateiName For Output AsDateiNr6. Print #DateiNr, a, b, c7. CloseEnd Sub

Zweites Programmprojekt


33

Zweites ProgrammprojektAuch bei dieser Prozedur steht nicht die Klassedes Programms im Vordergrund, sondern dieProgrammiertechniken. Grundlage ist unserWürfelspiel. Diesmal sollen drei Würfeleingesetzt werden. Dafür muss die Formnatürlich größer aufgezogen werden.Du startest Visual Basic und wählst wiederumdie STANDARD.EXEOberflächeEinen Vorschlag zur Oberfläche siehst du imBild. Die Kodierung erarbeiten wir anschließend.

Für diese Oberfläche werden Rahmenfelder oderFRAMES eingesetzt. Diese habenprogrammtechnisch keinen Nutzen – sie dienenschlicht zu Gestaltungszwecken. Mit ihrer Hilfelassen sich Gruppierungen von Objektengestalterisch vornehmen. In unserem Beispielfügen wir die Befehlsschaltflächen für die Zahlenoder die drei Bildfelder für die Würfelanzeigenin Rahmenfelder ein.Form.HEIGHT Höhe ca. 5950

WIDTH Breite 7040

CAPTION Beschriftung ""CONTROLBOX System-

MenüfeldFalse

BORDERSTYLE Rahmenform FesterDialog

BACKCOLOR Hintergrund-farbe

auswählen

Wie gesagt wird nur ein optischer Effekt erzeugt.Auf das Programm hat das keinen Einfluss, undwie du siehst, gibt es auch keine besonderenEigenschaften. Die Eigenschaft CAPTION spieltdie größte Rolle – damit hat es sich auch schon.Übrigens kannst du hier einen Schönheitstricknutzen – damit die CAPTION nicht so sehr an derRahmenlinie klebt, kannst du vor und nach demWert für sie ein Leerzeichen eingeben.Hast du die Form entsprechend der Tabelleeingerichtet und startest sie mit F5, stellst du fest,dass sie keine Titelleiste hat: wenn du den Wertfür CONTROLBOX auf FALSE setzt und BORDER-STYLE auf FESTER DIALOG, erhältst du eineForm, die nur aus einer einfachen Fläche besteht.Das bedeutet natürlich auch, dass die Schalt-flächen für MINIMIEREN, MAXIMIEREN undSCHLIEßEN fehlen.Einen Titel soll das Projekt natürlich haben. Alsosetzen wir ein Bezeichnungsfeld oder LABEL ein.Label1CAPTION Beschriftung Würfelspiel

mit VisualBasic 6.0

BORDER-STYLE

Randform Fest Einfach

ALIGNMENT Ausrichtung ZentriertFONT Schrift aussuchenFORECOLOR Schriftfarbe aus Palette

aussuchen

Unsere Arbeitsschritte sehen also so aus:• Zunächst speichern wir unser Projekt über

DATEI | PROJEKT SPEICHERN.• Dann erstellen wir die Rahmen über

DREIWÜRFEL.FRM ...• ... und die Würfel über DREIWÜRFEL.VBP ...und ziehen endlich das Rahmenfeld auf.



34

Soll ein Rahmenfeld sich wie ein Behälter für dieanderen Objekte verhalten, müssen Objekte im(!)Rahmenfeld aufgezogen werden. Setzt man sievon außen hinein, z.B. über Doppelklick auf dasWerkzeug und Drag & Drop, entsteht dasProblem, dass die angeordneten Objekte beimVerschieben des Rahmenfeldes an ihrem Platzliegen bleiben. Ziehst du die Objekte aber imRahmenfeld auf, werden sie mitverschoben.1. Zunächst ziehst du den ersten Rahmen auf:

Frame1CAPTION Beschriftung Würfelanzeige

(Leerzeichen nichtvergessen!)

2. Nun ziehst du im FRAME1 drei Bildfelder auf:

Picture 1 – 3NAME Name Würfel1,

Würfel2,Würfel3

BACKCOLOR

Hintergrundfarbe

aus Paletteaussuchen

3. Dann ordnest du im ersten Bildfeld SHAPE1bis SHAPE7 an, so wie wir das imvorhergehenden Programm 'Würfeln' getanhaben, ...

4. und wiederholst den Prozess in den anderenBildfeldern.

5. Die Namen für die Figuren sollen einenBezug zum jeweiligen Würfel haben: imersten Würfel bekommt SHAPE1 den NamenAuge1_1, SHAPE2 den Namen Auge2_1usw. Im zweiten Würfel heißen die Namendann Auge1_2, Auge2_2 usw. und imdritten Würfel Auge1_3, Auge2_3 usw.Das ganze sieht so aus:Auge1_1 Auge1_2 Auge1_3

Auge2_1 Auge2_2 Auge2_3






6. Nun legst du das zweite Rahmenfeld an, ...Frame2CAPTION Beschriftung Schaltflächen

7. ...ziehst sechs Befehlsschaltflächen auf, ...8. ... setzt CAPTIONS wie angezeigt ...9. ... und gibst ihnen die Namen

cmdEins, cmdZwei, cmdDrei,cmdVier, cmdFünf, cmdSechs

10. Fehlt noch das dritte Rahmenfeld:Frame3CAPTION Beschriftun

gErgebnisse

11. Hier setzt du drei Bezeichnungsfelder ein:

LabelsNAME Name lblGewonnen

lblVerlorenlblKapital


FONT Schrift aussuchenALIGNMENT Ausrichtung zentriertBORDER-STYLE

Randform Fest Einfach

FORECOLOR Schriftfarbe aussuchen

12. Für die Beschriftung der Bezeichnungsfelderlegst du wiederum drei Bezeichnungsfelderan und setzt als CAPTIONS: 'gewonnen','verloren', 'Kapital'.

13. Felt noch noch ein viertes Rahmenfeld für dieBefehlsschaltflächen Spielregeln undBeenden:

BefehlsschaltflächenNAME Name cmdSpielregel

n

CAPTION Beschriftung &Spielregeln

NAME Name cmdBeenden

CAPTION Beschriftung &Beenden



35

Wenn du den Wert der Eigenschaft Captioneinträgst, vergiss nicht das sogenannte'Kaufmännisch Und' (&). Dieses Zeichenveranlasst Windows-Programme dazu, denBuchstaben, vor dem es steht, zuunterstreichen. Damit kannst du das Klick-Ereignis mit der Tastenkombination ALT +(unterstrichener) BUCHSTABE auslösen. DasKlick-Ereignis Beenden wird also mit ALT+ B ausgelöst.

Willst du einzelne Objekte aufeinanderausrichten, kannst du das über Drag & Droperledigen. Genauer geht das, wenn du die WerteLEFT, TOP, HEIGHT, WIDTH unmittelbar änderst.Du musst dabei nicht immer den alten Wertlöschen, sondern kannst so lange neue Werteeingeben, bis du zufrieden bist; der alte Wertwird überschrieben.Sollen Objekte auf einer Linie ausgerichtetwerden, empfiehlt sich FORMAT | AUSRICHTEN:

Vergiss nicht, dass du bei gehaltener STRG-Tastemehrere Objekte gleichzeig markieren kannst.Vermutlich musst du die Sache etliche Maleausprobieren, bis du die Wirkungsweiseverstanden hast. Ausgerichtet wird immer andem Objekt, das die dunkleren Anfasser hat –meistens also an dem Objekt, das zuletztangeklickt wurde. Du musst dir also vorher überdie Reihenfolge klar sein.CodeDie Oberfläche steht nun also – fehlt noch dergesamte Code, der sie ans Laufen bringt.1. Du doppelklickst auf auf CMDBEENDEN ...2. ... und trägst im Prozedurrahmen

CMDBEENDEN_CLICK die Anweisung Endein.

3. Es müssen für jeden Würfel Zufallszahlenerzeugt werden.

4. Also doppelklickst du in eine freie Stelle derForm ...

5. ... und gibst im Prozedurrahmen FORM_LOADdie Anweisung Randomize ein – damit wirdbeim Start des Programms, also wenn dieForm in den Arbeitsspeicher geladen wird,der 'Zufallsgenerator' aktiviert.

6. Nun legst du die Prozedur Private SubComputer an.

7. Die folgende Prozedur zeigt den Code, mitdem in einer Schleife für jeden WürfelZufallszahlen erzeugt werden:1 Private Sub Computer()2 Dim i As Byte3 For i = 1 To 34 Zufallszahl(i) = Int(Rnd *

6) + 15 Next i6 End Sub

Bevor der Code erläutert wird, müssen wir denBegriff ARRAY erklären.In Programmen tauchen vielfach Gruppen vonVariablen auf, die gleichartig sind. In unseremFall taucht für jeden Würfel die VariableZUFALLSZAHL auf, die grundsätzlich keineUnterschiede aufweist. Also wird hier einVariablenfeld angelegt, in dem jede gleichartigeVariable einen Index zur Unterscheidungbekommt. So ein Variablenfeld nennt man einARRAY. Der Index ist in Klammern an dieVariable angefügt; und über ihn werden dieVariablen angesprochen.7. Hier sieht die Sache so aus:

Zufallszahl(1)Zufallszahl(2)Zufallszahl(3)

8. Wie deklariert man nun ein Array? Ähnlichwie einfache Variablen:Dim Zufallszahl(3)

9. Da die Variable auch in anderen Prozedurenbenutzt wird, deklarierst du sie imAllgemeinteil am Anfang des Code, alsohinter Option Explicit.

10. FOR-NEXT-Schleifen sahen wir uns imAbschnitt „Kontrollstrukturen“ auf Seite 28an. Innerhalb der Schleife werden drei



36

Zufallszahlen erzeugt und über den Indexjeweils der Variablen Zufallszahl()zugeordnet. Es können auch zwei oder dreigleiche Zahlen erzeugt werden. Soll derSpieler die Zahlen des Computers sehen,kannst du die Werte im sogenannteDirektfenster anzeigen lassen.

11. Zwischen Zeile 4 und Zeile 5 in der obigenProzedur gibst du folgende Zeile ein:Debug.Print Zufallszahl(i)

12. In der Prozedur FORM_LOAD gibst du denAufruf der Prozedur COMPUTER ein:Private Sub Form_Load()RandomizeComputerEnd SubNun werden nach jedem Programmstart imDirektfenster die drei vom Computer erzeug-ten Zahlen angezeigt. Mit der DEBUG.PRINT-Methode kannst du in diesem Fenster jedeVariable anzeigen und damit ganz einfachüberprüfen, welche Werte Variablen haben.

13. Manchmal ist das Direktfenster unübersicht-lich. Für diese Fälle lege ich mir ein Bezeich-nungsfeld an und lasse die Variable über dieEigenschaft CAPTION anzeigen.

14. Hast du dich überzeugt, dass das Programmbisher einwandfrei läuft, löscht du die Anwei-sung Debug.Print wieder – den AufrufCOMPUTER dagegen lässt du stehen.

15. Jetzt werden diese Zahlen auf die Würfel-anzeige übertragen – hier mit der MethodeSELECT-CASE. Das Prinzip siehst du imAbschnitt „Kontrollstrukturen“:Private Sub Anzeige1() Select Case Zufallszahl(1) Case 1 Eins1 Case 2 Zwei1 Case 3 Drei1 Case 4 Vier1 Case 5 Fünf1 Case 6 Sechs1 End SelectEnd Sub

16. Entsprechend der Zufallszahl steuert dasProgramm die Prozedur für die Augenanzeigean. Dort werden die Augen mit der bekanntenEigenschaft Visible = True/Falsedargestellt:Private Sub Eins1() Auge1_1.Visible = False Auge2_1.Visible = False Auge3_1.Visible = False Auge4_1.Visible = False Auge5_1.Visible = False Auge6_1.Visible = False Auge7_1.Visible = TrueEnd SubPrivate Sub Zwei1() Auge1_1.Visible = True Auge2_1.Visible = False Auge3_1.Visible = False Auge4_1.Visible = False Auge5_1.Visible = False Auge6_1.Visible = True Auge7_1.Visible = FalseEnd SubPrivate Sub Drei1() Auge1_1.Visible = True Auge2_1.Visible = False Auge3_1.Visible = False Auge4_1.Visible = False Auge5_1.Visible = False Auge6_1.Visible = True Auge7_1.Visible = TrueEnd SubPrivate Sub Vier1() Auge1_1.Visible = True Auge2_1.Visible = True Auge3_1.Visible = False Auge4_1.Visible = False Auge5_1.Visible = True Auge6_1.Visible = True Auge7_1.Visible = FalseEnd SubPrivate Sub Fünf1() Auge1_1.Visible = True Auge2_1.Visible = True Auge3_1.Visible = False Auge4_1.Visible = False Auge5_1.Visible = True Auge6_1.Visible = True Auge7_1.Visible = TrueEnd SubPrivate Sub Sechs1()



37

Auge1_1.Visible = True Auge2_1.Visible = True Auge3_1.Visible = True Auge4_1.Visible = True Auge5_1.Visible = True Auge6_1.Visible = True Auge7_1.Visible = FalseEnd Sub

17. Diese Prozeduren müssen für Anzeige2 undAnzeige3 wiederholt werden, wie du aus denbeiden folgenden Prozeduren ersiehst:Private Sub Anzeige2

Select Case Zufallszahl(2)

Case1

Eins2

usw.

End Select

Private Sub Anzeige3

Select Case Zufallszahl(3)

Case1

Eins3

usw....

End Select

18. Danach programmierst du die Anzeigen fürdie Augen der beiden anderen Würfel.

19. In der Click-Prozedur wird eine VariableSPIELER gebraucht. Diese wollen wir imAllgemeinteil deklarieren, um sie allenProzeduren zugänglich zu machen:

Dim Spieler As Byte

20. Nun doppelklickst du auf dieBefehlsschaltfläche CMDEINS und gibstfolgendes ein:

Private Sub cmdEins_Click() Spieler = 1 Computer

End Sub21. Das wiederholst du für CMDZWEI ... Private Sub cmdZwei_Click()

Spieler = 2 Computer

End Sub22. und so weiter bis CMDSECHS.

In den Prozeduren werden der Variablen dieunterschiedlichen Werte zugewiesen unddanach die Prozedur COMPUTER aufgerufen.Dort werden die Zufallszahlen erzeugt undmit den Prozeduren ANZEIGE1, ANZEIGE2und ANZEIGE3 angezeigt.

23. Bis auf die Auswertung der Eingaben müsstealles planmäßig funktionieren. Tippfehler inden Listings werden allerdings nicht alsFehler angezeigt, sondern verfälschen nur dieAnzeigen. Daher solltest du mehrfachüberprüfen, ob sich keine Tippfehlereingeschlichen haben – mit folgendem Code:1 Private Sub Auswertung()2 Static gewonnen As Byte3 Static verloren As Byte4 Static Kapital As Integer5 Dim i As Byte6 For i = 1 To 37 If Spieler =

Zufallszahl(i) Then8 gewonnen = gewonnen + 19 lblGewonnen.Caption =

gewonnen10 Kapital = Kapital + 111 lblKapital.Caption =

Kapital12 End If13 Next14 If Spieler <>

Zufallszahl(1) And _15 Spieler <> Zufallszahl(2)

And _16 Spieler <> Zufallszahl(3)

Then17 verloren = verloren + 118 lblVerloren.Caption =

verloren19 Kapital = Kapital - 120 blKapital.Caption =

Kapital21 End If22 End SubBis zur Zeile 13 bietet der Code nichts Neues.Innerhalb der Schleife wird geprüft, ob dieVariable Spieler den gleichen Wert wie dieVariable Zufallszahl hat.

24. Es war die Absicht, dass dem Spieler beigleichen Würfelanzeigen mehrfach dasKapital erhöht wird. Damit er eine größere



38

Chance gegen den Computer hat, sollen dieVerluste nicht mehrfach zählen:1 For i = 1 To 32 If Spieler = Zufall

zahl(i) Then3 gewonnen = gewonnen + 14 lblGewonnen.Caption =


Kapital7 ElseIf Spieler <> Zufalls-

zahl(1) And _8 Spieler <> Zufall

zahl(2) And _9 Spieler <> Zufalls-

zahl(3) Then10 verloren = verloren + 111 lblVerloren.Caption =

verloren12 Kapital = Kapital - 113 lblKapital.Caption =

Kapital14 End If15 Next

25 In dieser Prozedur wird durch eine andereProgrammiertechnik erreicht, dass dieNichttreffer mehrfach hochgezählt werden.Die folgende Prozedur zeigt eine andereCodierweise:1 For i = 1 To 32 If Spieler = Zufalls-

zahl(i) Then3 gewonnen = gewonnen + 14 l blGewonnen.Caption =


Kapital7 ElseIf Spieler <> Zufalls-

zahl(i) Then8 verloren = verloren + 19 lblVerloren.Caption =

verloren10 Kapital = Kapital - 111 lblKapital.Caption =

Kapital12 End If13 Next

Für welche Variante du dich entscheidest,bleibt dir überlassen. Man könnte an dieserStelle beispielsweise eineAuswahlmöglichkeit für Schwierigkeitsgradeeinbauen.

26 Zeile 14 – 16 in der Prozedur zurAuswertung, Seite 37, und Zeile 7 – 9 in derersten der beiden eben angeführtenProzeduren zur Schleifenabfrage auf Seite 38haben eine Besonderheit. Der Code gehört ineine zusammenhängende Zeile. Die Zeilewird dadurch ziemlich lang und kann nurnoch über die Bildlaufleisten eingesehenwerden. Visual Basic erkennt den Unterstrichals Trennzeichen einer Zeile und verbindetintern die Zeilenteile wieder. Wichtig ist einLeerzeichen vor dem Unterstrich. Wenn dudie Zeilenteile im Codefenster etwaseinrückst, ist besser erkennbar, welche Teilezusammen gehören

27 Zum Abschluss wird die Spielanleitungprogrammiert. Den Text überlasse ich dir.Eine Möglichkeit ist, eine Mitteilungsboxanzulegen:Private SubcmdSpielregeln_Click() Dim Titel As String Dim Meldung As String Titel = "Spielanleitung" Meldung = Meldung + "DerComputer würfelt dreiZufallszahlen." + Chr$(10) +Chr$(13) Meldung = Meldung + "Dukannst gegen den Computerwürfeln, " + Chr$(10) +Chr$(13) Meldung = Meldung + "usw." MsgBox Meldung, vbOKOnly,TitelEnd Sub

Größere Gestaltungsmöglichkeiten hast du, wenndu eine zweite Form verwendest. Dazu musst duwissen, dass es zwei Möglichkeiten gibt, einFormular zu laden. Über die LOAD-Anweisungwird ein Formular nur in den Speicher geladen,aber nicht angezeigt – mit der SHOW-Methodedagegen wird die Form geladen und angezeigt.



39

Der umgekehrte Weg, nämlich eine Form wiederlos zu werden, verwendet analog zweiMöglichkeiten. Soll eine Form komplett aus demArbeitsspeicher entfernt werden, wird sie mit derUNLOAD-Anweisung entladen, ansonstenversteckt man sie nur mit der HIDE-Methode.Du aktivierst PROJEKT | FORMULAR HINZUFÜGENund wählst ein Formular.Wie du siehst, hat Visual Basic verschiedeneDialog-Formulare in seinem Angebot, die auchschon mit Code versehen sind. Die solltest dualle einmal ausprobieren. Im Projektfenster istdie neue Form als FORM2 angezeigt. WennProgramme klein sind und nur wenigeProjektteile enthalten, belasse ich es meistens beiden vorgegebenen Namen. Hier könntest du aberz.B. FRMANLEITUNG als Name eingeben.Du doppelklickst auf CMDSPIELREGELN undgibst folgenden Code ein:

Private SubcmdSpielregeln_Click() frmAnleitung.ShowEnd Sub

Dann drückst du auf F5 und dann aufSPIELREGELN.Die Form FRMANLEITUNG kannst du mit deinenKenntnissen so gestalten, wie du es möchtest.Entweder setzt du die Print-Methode für denText ein, oder du legst dir ein Textfeld an, oderdu verwendest ein Bildfeld oder ... In jedem Fallmuss eine Prozedur geschrieben werden, mit derdas Fenster wieder geschlossen wird. Alsodoppelklickst du auf FRMANLEITUNG, wählst einCLICK-Ereignis und gibst folgenden Code ein:

Private Sub Form_Click() frmAnleitung.HideEnd Sub

Die Spielanleitung wird nur versteckt. Dadurchsteht sie dem Spieler immer wieder sehr schnellzur Verfügung. Eine Befehlsschaltfläche mit demCLICK-Ereignis ist vielleicht offensichtlicher.Zumindest solltest du darauf hinweisen, dass dieForm durch einen Klick geschlossen werdenkann, z.B. als CAPTION.Du wählst DATEI | FORM FRMANLEITUNGSPEICHERN UNTER ... und gibst als NameAnleitung ein

Zum Abschluss setzen wir noch einMitteilungsfenster ein für den Fall, dass dasKapital weniger als Null, bzw. größer als 25wird. Der Wert soll nur ein Lob für eine guteLeistung sein; du kannst selber festlegen, abwann gutes Würfeln gelobt werden soll.Die Abfrage fügst du in unseren Code zurFehlerüberprüfung auf Seite 37 zwischen Zeile 5und Zeile 6 ein:

If Kapital < 0 Then AlarmIf Kapital > 25 Then Loben

Du legst die Prozedur ALARM an:1. Private Sub Alarm()2. Dim Titel As String3. Dim Meldung As String4. Dim Schaltfläche As Byte5. Titel = "ALarm"6. Meldung = "Du bist leider pleite!"7. Schaltfläche = MsgBox(Meldung, 1 + 16, Titel)8. If Schaltfläche = 1 Then9. End10. End If11. End Sub

In der Prozedur ALARM wird einMitteilungsfenster als Funktion ausgegeben. InZeile 7 wird der Variablen SCHALTFLÄCHE einWert des Mitteilungsfensters zurückgegeben, derin Zeile 8 abgefragt wird. Wird der Wert 1zurückgegeben, also die Schaltfläche OKangeklickt, soll das Programm beendet werden.Alle anderen Eingaben haben keine Wirkung.Folglich wird bei Abbrechen zumSpielprogramm zurückgekehrt.



40

Nun legst du die Prozedur LOBEN an:1. Private Sub Loben()2. 'blinken3. Dim i As Byte4. For i = 0 To 155. Form1.BackColor =

QBColor(i)6. Frame1.BackColor =




QBColor(i)10. verz 0.111. Next12. Form1.BackColor =

&H8000000F13. Frame1.BackColor =




&H8000000F17. End Sub

In der Schleife, Zeile 4, werden dieHintergrundfarben der Form sowie der Rahmenfünfzehn Mal mit den Standardfarben versehen.Damit es nicht zu schnell geht, habe ich beijedem Schleifendurchlauf eine Verzögerungeingebaut:

1. Private Sub verz(zeit!)

2. Dim zeit1 As Variant

3. zeit1 = Timer

4. Do

5. DoEvents

6. Loop Until (Timer - zeit1>zeit)

7. End Sub

Danach werden die Farben wieder auf ihrenUrsprungswert gesetzt.Die Prozedur VERZ(ZEIT!)ist ziemlich verzwickt,weswegen ich dir empfehle, sie einfach zuübernehmen – dem unbekannten Autor seigedankt!

Grafik


41

GrafikUnter Windows muss man sich die gesamteBildschirmdarstellung als Grafik vorstellen.Auch Text-Ausgaben sind eine Form von Grafik.Visual Basic bietet grundsätzlich zweiMöglichkeiten, Grafik einzusetzen:1. Grafik-Steuerelemente mit ihren

Eigenschaften und Methoden aus derWerkzeugsammlung

2. GDI-Funktionen (Graphical DeviceInterface)

Bis auf bestimmte Spezialfälle, wie z.B.Polygone, stehen für die gängige Grafik-Programmierung genügend Visual Basic-Komponenten zur Verfügung.

GrundlagenGrafikoperationen sind gleichermaßen imFenster, also in der FORM, auf dem Drucker oderin einem Bildfeld möglich. Für alle dreiKomponenten gelten gleiche Methoden.MethodenGrafikausgaben beziehen sich grundsätzlich aufein bestimmtes Objekt, also nicht auf dengesamten Bildschirm. So kann eine Ausgabe mitder Methode PRINT auf einem Drucker erfolgen,aber auch in einem Bildfeld oder in der Form.Methoden BeschreibungenLINE zeichnet eine Linie oder ein

RechteckCIRCLE zeichnet einen Kreis, eine Ellipse

oder einen BogenPSET setzt einen PunktPOINT ermittelt die Farbe eines PunktesPRINT gibt eine Zeichenfolge ausCLS löscht den Inhalt des Objektes

1. Du startest Visual Basic, ...2. gibst der FORM den NAMEN frmHaupt ...3. ... und speicherst sie als GRAFIK14. Dann ziehst du in der Form ein großes

BILDFELD auf, ...5. ... und setzt als NAME picGrafik1

6. Jetzt erstellst du eineBEFEHLSSCHALTFLÄCHE.

7. Hier setzt du als NAME cmdSchließen ... ... und als CAPTION Ende.8. Du erstellst noch eine Befehlsschaltfläche, ...9. ... setzt als NAME cmdZeichnen ...10. ... und als CAPTION Zeichnen.11. Dann doppelklickst du auf CMDZEICHNEN ...

Der Code lautet: Private Sub

cmdZeichnen_Click() picGrafik1.Line (100, 100)-

(500, 500)End Sub

12. ... drückst auf F513. ... und endlich auf ZEICHNEN. Nach F5 wird eine Linie von links oben nach

rechts unten gezeichnet.14. Nun doppelklickst du auf CMDSCHLIEßEN, ...15. setzt End,...16. ... beendest das Programm und vergrößerst

das Bildfeld ...17. ... und drückst wiederum F5Die Linie befindet sich innerhalb des Bildfeldesan derselben Position.Es taucht die Frage auf, ob die Linie von linksoben nach rechts unten oder umgekehrtgezeichnet wird – bei derArbeitsgeschwindigkeit des Computers kannman nicht erkennen, in welche Richtunggezeichnet wurde. Dazu benötigen wir einigegrundlegende Kenntnisse.EigenschaftenSchüler kennen ein beliebtes Spiel, dasvornehmlich im langweiligen Unterricht gespieltwird: »Schiffe versenken«. Verwendet wird einkariertes Papier – aus guten Gründen meist ausdem Mathe-Heft.Jedes Kästchen hat durch die Angaben für dieZeile und die Spalte einen festgelegten Platz. Das'x' befindet sich in Zeile '4' und Spalte 'd'. Mit derAngabe 4/d wird der Ort bestimmt, an dem sicheindeutig das 'x' befindet.

Grafik


42

a b c d e f g h i j1234 x5678910

So etwa musst du dir den gesamten Bildschirm,eine FORM oder – wie hier – ein Bildfeldeingeteilt vorstellen, mit dem Unterschied, dassdie Einteilungen viel feiner vorgenommenwerden können und dass keine Buchstabenverwendet werden.Visual Basic verwendet standardmäßig einebesondere Maßeinheit: Twips. Ein Kästchen istein Twip. Der Vorteil dieser Maßeinheit liegtdarin, dass sie systemunabhängig ist, also auchmaßstabsgetreu zeichnet, wenn eine andereBildschirmauflösung verwendet wird. DasKoordinatensystem ist standardgemäß aufgebaut,also beginnen die Zeilen und Spalten links obenmit dem Wert 0; 0/0 ist die linke obere Ecke.In der Mathematik werden solche Koordinatenmit den Buchstaben x und y bezeichnet. DieKoordinaten bewegen sich auf der y-Achse vonoben nach unten und auf der x-Achse von linksnach rechts. Diese Darstellung ist für uns etwasungewohnt. Wir kennen z.B. bei grafischenDarstellungen eher den umgekehrten Weg, dasssich die y-Achse von unten nach oben bewegt.Wie alles in Visual Basic lässt sich auch diesesändern. Dazu später mehr.In unserer Prozedur CMDZEICHNEN_CLICKhatten wir folgende Anweisung formuliert:

picGrafik1.Line(100,100) – (500,500).

PICGRAFIK1 ist das Bildfeld, und nach einemPunkt als Trennzeichen wird LINE als Methodefestgelegt. Dann folgen die Zahlenpaare(100,100) als Startpunkt und (500,500)

als Endpunkt. Zu Übungszwecken kannst duauch andere Zahlen verwenden.Wichtig ist, dass die Linie bei (x1,y1)beginnt und bei (x2,y2) aufhört.Nun klickst du das Steuerelement LINE imWERKZEUG-Fenster an und legst die neue Linieirgendwo im Bildfeld ab, indem du denMauszeiger ins Bildfeld setzt, die linkeMaustaste drückst und ziehst.Im EIGENSCHAFTEN-Fenster findest du u.a. dieEigenschaften X1, X2, Y1 und Y2. Danebenstehen in der Werteliste die entsprechendenAngaben.Klickst du einen Anfasser der Linie an, kannst duihre Lage durch Ziehen verändern. Lässt du dieMaustaste los, werden die neuenKoordinatenwerte angezeigt. Probiere einbisschen herum, damit du ein Gefühl dafürbekommst, wie die Lage der Linie im Bildfeldbeschrieben wird.Von den wenigen Eigenschaften einer Linie sindfür uns BORDERCOLOR, BORDERSTYLE undBORDERWIDTH interessant. Damit können dieFarbe, die Darstellung und die Stärke der Linieeingestellt werden.Dazu eine kleine Prozedur:

Private Sub Form_Load() frmHaupt.Height = 7000 'Me.Height = 7000 Me.Width = 6000 picGrafik1.Height = 5200 picGrafik1.Width = 5200End Sub

Diese Prozedur hat als Startanweisung dieGrößendarstellung der Form. Die Höhe der Formhat einen Wert von 7000 Twips. Mit demSchlüsselwort ME kann man den Namen einesObjektes ersetzen, für das gerade Codegeschrieben wird – ME bedeutet soviel wie 'ich'oder 'meine'.Nun geben wir die Abmessungen des BildfeldesPICGRAFIK1 an. Damit wird sichergestellt, dasssowohl die Form als auch das Bildfeld diepassenden Abmessungen für die folgendenOperationen haben.Die Aufgabe ist, bei jedem Klick auf dieZEICHNEN-Befehlsschaltfläche eine Linie mitzufälligen Anfangs- und Endpunkten zu

Grafik


43

zeichnen. Dazu werden die Punkte X1, X2, Y1und Y2 zufällig über die RND-Funktion erzeugtund dann der Methode LINE als Wertezugewiesen:

1. Private Sub cmdZeichnen_Click()2. Randomize3. Dim x1 As Single, x2 As Single4. Dim y1 As Single, y2 As Single 5. x1 = Int(Rnd * 4000)6. x2 = Int(Rnd * 4000)7. y1 = Int(Rnd * 4000)8. y2 = Int(Rnd * 4000) 9. picGrafik1.Line (x1, y1)-(x2, y2)10. End Sub

Die Eigenschaft BorderColor, also die Farbe derLinie, steht uns nur zur Entwicklungszeit zurVerfügung, zur Laufzeit wird die EigenschaftFORECOLOR verwendet. Die QBCOLOR-Funktion beinhaltet nur ein Spektrum von 16Standardfarben, die mit den Werten von 0 – 15beschrieben werden; da sie sich sehr einfacheinsetzen lässt, wird sie gerne für einfacheFarbgestaltungen verwendet.Farbe = QBColor(10) für Hellgrün merktman sich eher als Farbe = RGB(255,0,0)für Rot. Allerdings kann man mit der QBCOLOR-Funktion nur 16 Farbwerte einstellen, mit derRGB-Funktion dagegen unzählige Abstufungen,da die drei Farbanteile jeweils einen Wertzwischen 0 und 255 annehmen können. In derProzedur CMDZEICHNEN_CLICK werdenfolgende Befehlszeilen hinzugefügt:

Dim Farbe as IntegerFarbe = Int(Rnd * 15)picGrafik1.ForeColor =QBColor(Farbe)

Damit die Linien dicker aussehen, setzt du nochfolgende Zeile ein:

picGrafik1.DrawWidth = 3Dadurch wird die Zeichenstärke der Linieeingestellt. Probiere auch größere Werte aus.

Farben (RGB-Funktion)Farbe RGB-Wert Rot-

anteilGrünanteil

Blau-anteil

Schwarz &H00 0 0 0

Blau &HFF0000 0 0 255

Grün &HFF00 0 255 0

Cyan(Türkis)

&HFFFF00 0 255 255

Rot &HFF 255 0 0

Magenta(Violett)

&HFF00FF 255 0 255

Gelb &HFFFF 255 255 0

Weiß &HFFFFFF 255 255 255Farben (QBColor-Funktion)Farbe Wert Farbe WertSCHWARZ

0 Grau 8

BLAU 1 Hellgrau 9

GRÜN 2 Hellgrün 10

TÜRKIS 3 HellTürkis 11

ROT 4 Hellrot 12

VIOLETT

5 Hellviolett 13

BRAUN 6 Gelb 14

WEIß 7 Hellweiß 15

Eine Entschuldigung: die Farben der Linienkönnen ganz einfach erreicht werden, indem manfolgenden Code schreibt:

picGrafik1.Line(x1, y1)-(x2, y2),QBColor(Farbe)

Für die Variable Farbe wird die Zahl dergewünschten Farbe eingesetzt, also z.B.QBColor (10). Mir ging es nur darum, dassdie Farbgebung deutlich wird.

Grafik


44

Die Methode LINE kann noch mehr als nurStriche in das Bildfeld zeichnen. Die Anfangs-und Endkoordinaten bestimmen nicht nurAnfang und Ende einer Linie, sondern auch diegegenüberliegenden Ecken eines Rechtecks

picGrafik1.Line(x1, y1)-(x2, y2),QBColor(Farbe), B

Dieser Code erzeugt Rechtecke mit denAnfangskoordinaten als linke obere Ecke undden Endkoordinaten als rechte untere Ecke in dergewünschten Farbe – das abschließende B istwichtig, da es das Rechteck aktiviert. Drückst duauf F5, wird das Ergebnis angezeigt.Der nächste Code erzeugt ein ausgefülltesRechteck:

picGrafik1.Line(x1, y1)-(x2, y2),QBColor(Farbe), BF

Vergiss auch hier nicht die letzten beiden Code-Buchstaben!Nun wählst du DATEI | SPEICHERN VONGRAFIK1.FRM UNTER ... und gibst als NameGRAFIK2ein.Dann wählst du DATEI | PROJEKT SPEICHERNUNTER ... und gibst wiederum den NamenGRAFIK2 anSchließlich löschst du den Code in CMDZEICH-NEN_CLICK mit Ausnahme der Variablen-deklarationenLässt du den Computer Berechnungen ausführen,erzielst du hübsche überraschende Effekte:

1. Private SubcmdZeichnen_Click()

2. Dim i As Integer3. Dim x1 As Single,

x2 As Single4. Dim y1 As Single,

y2 As Single5. Dim Faktor As Integer 6. x1 = 100: x2 = 20007. y1 = 100: y2 = 20008. Grafik1.DrawWidth = 109. Faktor = 7.5 10. For i = 0 To 254

11. picGrafik1.Line (x1 + Faktor * i, y1 + Faktor * i)- _12. (x2 + Faktor * i, y2 + Faktor * i), RGB(i, 0, 0), B13. Next14. End Sub

In einer Schleife werden nacheinander 255Rechtecke gezeichnet. Die Zeilen 11 und 12gehören hintereinander. Der Startpunkt x1errechnet sich aus der Variablen x1 mit demWert 100 plus dem Faktor mit dem Wert 7.5 *i . i hat zu Beginn der Schleife den Wert 0,d.h. der Startpunkt x1 = x1 + 7.5 * 0 =107.5. Der Startpunkt für y1 und dieEndpunkte errechnen sich entsprechend.Für die Farbe wurde die RGB-Funktioneingesetzt. Der Farbwert ändert sich bei jedemSchleifendurchlauf von RGB(0,0,0) bisRGB(254,0,0). So entsteht der Effekt einesFarbtunnels.Eine andere häufig eingesetzte Methode istCIRCLE. Mit dieser Methode wird ein Kreis, eineEllipse oder auch nur ein Kreisbogen gezeichnet.Die neuen Kenntnisse über dasKoordinatensystem gelten auch hier.Du löschst den aktuellen Code und setzt dennachfolgenden ein:


2. Dim x1 As Single, y1 As Single

3. Dim Radius As Single 4. x1 = 500: y1 = 5005. Radius = 3006. picGrafik1.Circle (x1,

y1), Radius, QBColor(12)

7. End SubDann wählst du DATEI | SPEICHERN VONGRAFIK2.FRM UNTER ... mit dem NamenGRAFIK3 sowie DATEI | PROJEKT SPEICHERNUNTER ... mit dem Namen GRAFIK3Der Einsatz der Methode entspricht demVorgang bei LINE. Allerdings benötigt man nurden Mittelpunkt des Kreises imKoordinatensystem und den Radius des Kreises

Grafik


45

in der obigen Prozedur. Für exaktemathematische Berechnungen müsstenKenntnisse über Bogenmaß und Gradmaßvorhanden sein. Das führt uns hier zu weit.Die Spielereien, die mit der RND-Funktion beimThema LINE gemacht wurden, kannst du dir hierselber programmieren.Als Eigenschaften kommen im allgemeinen nurFILLCOLOR als Farbe für das Ausfüllen desKreises und FILLSTYLE in Frage als Möglichkeit,verschiedene Hintergrundmuster zu benutzen.Willst du die Wirkung sehen, benutzt du dasWerkzeug SHAPE: du ziehst mit der Maus eineFigur im Bildfeld oder in der Form auf. ImEIGENSCHAFTEN-Fenster kannst du derEigenschaft verschiedene Werte zuweisen, u.a.auch den Wert 3-Kreis. Die EigenschaftFILLSTYLE lässt dir jede Menge Möglichkeiten.Klicke alle Möglichkeiten an, um die Darstellungbeurteilen zu können. Während der Laufzeitkannst du natürlich auch bestimmte vomProgramm vorgegebene FILLSTYLES zuweisen,so für vertikale Linien Shape1.FillStyle= 3


2. Dim x1 As Single, y1 As Single

3. Dim Radius As Single 4. x1 = 500: y1 = 5005. Radius = 300 6. picGrafik1.FillColor =

QBColor(8)7. picGrafik1.FillStyle = 08. picGrafik1.DrawWidth = 39. picGrafik1.Circle (x1,

y1), Radius, QBColor(12)

10. End Sub

Zeile 6 in in dieser Prozedur bestimmt dieFüllfarbe, Zeile 7 die Darstellung, Zeile 8 dieStärke der Kreislinie und Zeile 9 zeichnet dieFigur mit der entsprechenden Linienfarbe.Du speicherst wie üblich alles unter GRAFIK4und löschst den Code in der ProzedurCMDZEICHEN_CLICK.

Die CIRCLE-Methode hat verschiedeneEingabeparameter, wie z.B. (x1, y1) oder Radius.Diese Parameter erwartet Visual Basic in einerbestimmten Reihenfolge. Zuerst also denMittelpunkt, dann den Radius, dann die Farbe.Danach erwartet Visual Basic Werte für denStartwert eines Kreisbogens, seinen Endwert unddas Verhältnis der Querachse des Kreises zurLängsachse. Sagst du, dass in einem Kreis alleAchsen gleich lang sind, hast du recht – das istaber bei einer Ellipse nicht der Fall. DasVerhältnis von Querachse zur Längsachse nenntman Aspekt.Das Zeichnen der Ellipse ist, wie du in dernachfolgenden Prozedur sehen wirst, keinProblem. Visual Basic erwartet aber wie gesagtauch den Start- und Endwert für einenKreisbogen. Werden bestimmte Parameter nichtangegeben, weil man sie nicht benötigt, genügtes, keine Angabe zu machen und nur ein Kommaeinzugeben. Das Komma steht gewissermaßenals Platzhalter für 'kein Wert'. Mit dernachfolgenden Prozedur werden drei Ellipsengezeichnet, die unterschiedliche Verhältnisse derAchsen zueinander haben.

1. Private Sub cmdZeichnen_Click()2. Dim x1 As Single,

y1 As Single3. Dim Radius As Single4. x1 = 2500: y1 = 25005. Radius = 10006. picGrafik1.Circle

(x1, y1), Radius, QBColor(4), , , 0.5

7. picGrafik1.Circle (x1, y1), Radius, QBColor(5), , , 2

8. picGrafik1.Circle (x1, y1), Radius, QBColor(6), , , 3

9. End SubDu löschst den Code, ohne zu speichern, da wirnur eine kleine Demonstration erstellt haben.In den erweiterten Versionen von Visual Basicgibt es ein Steuerelement, mit dem man Datengrafisch darstellen kann, z.B. als Säule oder alssogenannte Tortendiagamm. So einTortendiagramm wollen wir jetzt selber

Grafik


46

herstellen. Dazu benötigen wirmathematischeVorkenntnisse. Ich hatte schonerwähnt, dass zwei unterschiedliche Maßangabenfür einen Kreisbogen vorhanden sind: dasGradmaß – ein Vollkreis hat 360°, ein RechterWinkel 90° – und das Bogenmaß. Wir messennormalerweise Winkel in Grad, also benötigenwir ein Formel, die den Computer zwingt, so zurechnen, wie wir das wollen.Ohne in Einzelheiten zu gehen, nur so viel: dieKreiszahl π (Pi) hat einen abgerundeten Wertvon 3,14159. 1° hat also den Wert π/180. Wollenwir einen Kreisbogen berechnen, der einenWinkel von 45° umschließt, muss der Computer45 * (π / 180) berechnen.Berücksichtigt werden mussnoch, wie der Computer dieWinkelangaben sieht. Woliegt für ihn 0°? Stelle dir dazudas Ziffernblatt einer Uhr vor.Bei 3-Uhr liegt 0°, und eswird gegen den Uhrzeigersinn weitergezählt, sodass oben 90°, bei 9 Uhr 180° und bei 6 Uhr270° liegt.Wollen wir einen Kreisbogen von 0°bis 67° zeichnen, heißt die Anweisung also:

picGrafik1.Circle (x1, y1),Radius, QBColor(15),0 * (3.14159 / 180),67 * (3.14159 / 180)

Du löschst den Code in CMDZEICHEN_CLICK bisauf die Dim-Zeilen und gibst diese Zeile ein.Wir legen eine Variable bogen an, die uns denjeweiligen Wert berechnet – sie steht in Zeile 5der nachfolgenden Prozedur. Es muss also nurdie gewählte Gradzahl mit dem Faktor BOGENmultipliziert werden:

1. Private Sub cmdZeichnen_Click()2. Dim x1 As Single,

y1 As Single3. Dim Radius As Single4. Dim bogen As Single5. bogen = 3.14159 / 1806. x1 = 3000: y1 = 30007. Radius = 15008. picGrafik1.Circle

(x1, y1), Radius, _9. QBColor(15), 0 * bogen,

67 * bogen10. End Sub

Der nächste Schritt auf dem Weg zumKuchendiagramm ist sehr einfach. Die MethodeCIRCLE fügt eine Linie vom Start- bzw.Endpunkt des Kreisbogens zum Mittelpunkt ein,wenn die Werte negativ sind. Also setzt du einMinus vor die 0 und vor 67.Enttäuscht? Nun ja – offensichtlich gibt es fürVisual Basic kein minus 0. Das Problembekommst du mit hinreichender Genauigkeitgelöst, wenn du anstatt 0 den Wert 0.000001einsetzt. Das millionstel Grad ist nichtbemerkbar, der Computer wird aber überlistet –denn die Zahl–0.000001 gibt es natürlich.Füge noch folgende Zeilen in den Code ein:

picGrafik1.FillStyle = 0 '(dasist der Wert für 'ausgefüllt')picGrafik1.FillColor =QBColor(5)

Das Tortenstück ist fertig, das Prinzip bekannt.Wenn man jetzt bedenkt, dass ein Kreis 360° hat,kann man natürlich jeden Anteil des Kreisesberechnen und zeichnen lassen. Nehmen wir an,dass wir drei Werte haben, nämlich 67, 53, 90,die anteilmäßig als Tortenstücke dargestelltwerden sollen.

1. picGrafik1.FillStyle = 02. picGrafik1.FillColor =

QBColor(5)3. picGrafik1.Circle (x1, y1),

Radius, QBColor(15),-0.00001 * bogen,-67 * bogen

4. picGrafik1.FillColor =QBColor(4)

5. picGrafik1.Circle (x1, y1),Radius, QBColor(15),-67 * bogen, -120 * bogen

6. picGrafik1.FillColor =QBColor(3)

7. picGrafik1.Circle (x1, y1),Radius, QBColor(15),-120 * bogen, -210 * bogen

Verwendest du diese Prozedur, bekommst duzwar schöne Tortenstückchen – aber die richtigeLösung ist das noch nicht. Um zu einer passablenLösung zu kommen, müssen wir einigeVorüberlegungen anstellen.

Grafik


47

1. Private Sub cmdZeichnen_Click()2. Dim x1 As Single, y1 As Single3. Dim Radius As Single4. Dim Bogen As Single5. Dim a As Single, b As Single, c As Single6. Dim ges As Single7. Dim ProzAntA As Single, ProzAntB As Single, ProzAntC As Single8. Dim WinA As Single, WinB As Single, WinC As Single9. a = 67: b = 53: c = 9010. ges = a + b + c11. ProzAntA = a * 100 / ges12. ProzAntB = b * 100 / ges13. ProzAntC = c * 100 / ges14. WinA = 360 * ProzAntA / 10015. WinB = 360 * ProzAntB / 10016. WinC = 360 * ProzAntC / 10017. Bogen = 3.14159 / 18018. x1 = 3000: y1 = 300019. Radius = 150020. picGrafik1.FillStyle = 021. picGrafik1.FillColor = QBColor(5)22. picGrafik1.Circle (x1, y1), Radius, QBColor(15), -0.00001 *

Bogen, -WinA * Bogen23. picGrafik1.FillColor = QBColor(4)24. picGrafik1.Circle (x1, y1), Radius, QBColor(15), -WinA * Bogen,

-(WinA + WinB) * Bogen25. picGrafik1.FillColor = QBColor(3)26. picGrafik1.Circle (x1, y1), Radius, QBColor(15), -(WinA + WinB)

* Bogen, -(360) * Bogen27. End Sub

Jeder Wert ist ein prozentualer Anteil derGesamtsumme. Also berechnen wir dieGesamtsumme und speichern sie in derVariablen GES in der Zeile 10 der obigenProzedur. Dann werden die jeweiligenprozentualen Anteile der Werte an derGesamtsumme berechnet und gespeichert (Zeilen11–13). Jetzt brauchen wir noch die Winkel fürdie Werte. Hier müssen wir davon ausgehen,dass die Bezugsgröße der Vollkreis mit 360° ist.In Zeilen 14–16 werden die Berechnungenvorgenommen.Es wird spannend (Zeile 22). Der errechneteWinkel soll von 0 bis zu seinem Wert WinAgehen. Mit den Minuszeichen bekommen wirbekanntlich die Radien.Wir drücken ganz nach alter Gewohnheit F5.Hast du alles sauber programmiert, müsste jetztein Tortenstückchen zu sehen sein, das dem Wertvon 67° im Vollkreis entspricht.

Damit das nächste Stück an das bestehendeanschließt, dürfen wir natürlich nicht wieder 0als Startwert nehmen, sondern den Endwert desbestehenden Kreisbogens (Zeile 24). Der neueEndwert errechnet sich aus dem Kreisbogen,bzw. Winkel a+b. In Zeile 26 werden dieWerte für das letzte Stück eingesetzt; derEndwert ist logischerweise 360.Kleine Ungenauigkeiten nehmen wir in Kauf –wer es genauer haben will, muss mitWinkelfunktionen arbeiten. Wer es ganzprofessionell haben will, gibt Geld aus undbeschafft sich ein Steuerelement für Diagramme.Der nächste Schritt besteht darin, eigene Wertein Textfelder einzugeben. Wir löschen den Codein der Prozedur FORM_LOAD und gestalten dieGröße der Form und des Bildfeldes mit eigenenWerten. Das Bildfeld sollte etwa eine Höhe undBreite von 4000 Twips haben, die Form etwa5800 in Höhe und Breite.

Grafik


48

Nun wollen wir drei Textfelder einrichten.drei TextfelderTABINDEX 0, 1, 2

TEXT = ""

NAME txtZahl1, txtZahl2,txtZahl3

1. Im Allgemeinteil deklarieren wir dieVariablen a, b und c als Single, damit sie injeder Prozedur des Projekts gelten.

2. Nun löschen wir die Variablendeklaration füra, b und c in der Prozedur CMDZEICHNEN_CLICK ...

3. dann die Zeile 9 der obigen Prozedur mitden Werten für a, b und c ...

4. und tragen schließlich folgenden Code indie Prozedur ein:x1 = picGrafik1.Width / 2: y1= picGrafik1.Height / 2

Die Werte für x1 und y1 ergeben sich ausder Hälfte der Breite und Höhe desBildfeldes; damit ist der Mittelpunkt desKreises genau in der Mitte.

5. In der Prozedur txtZahl1_Change, die soaussieht:

Private Sub txtZahl1_Change() a = Val(txtZahl1.Text)

End Sub wird der Wert für die Variable a eingegeben.

Da Visual Basic alle Eingaben in ein Textfeldals Zeichenketten oder STRINGS betrachtet,muss der Wert mit der VAL-Funktion in einenZahlenwert umgewandelt werden, denn miteiner Zeichenkette können wir nicht weiterrechnen.

Über die Maus oder TAB werden dieTextfelder angesteuert; deswegen sind dieTabindices in der entsprechenden Reihenfolgeangelegt worden. Für die anderen beidenTextfelder müssen identische Codesgeschrieben werden.

6. Damit man die Eingaben auch mit EINGABEabschließen kann und das nächste Textfeldangesprungen wird, tragen wir in dieProzedur Key Press folgenden Code ein:

Private SubtxtZahl1_KeyPress(KeyAscii AsInteger)

If KeyAscii = 13 Then

SendKeys "{TAB}"

End If

End Sub

Damit wird geprüft, ob die Eingabetaste(KeyAscii = 13) gedrückt wurde. Wennja, wird der Befehl SENDKEYS verwendet, derin diesem Fall das gleiche bewirkt wie dieTAB-Taste –SENDKEYS bedeutet 'Sende dieTaste', es also wird der Tastendruck simuliert,der in den geschweiften Klammern steht, etwa{F5} oder {Esc}.

Fehlen auf deiner Tastatur die Zeichen für diegeschweiften Klammern, erzeugst du sie mitALT + 0123 für '{' und ALT + 0125 für '}'; dumusst den Zahlenblock benutzen!

7. Damit man weiß, welche Farbe zu welchemWert gehört, werden die Eigenschaften wie inder folgenden Prozedur gesetzt:8 Private Sub Form_Load()9 TxtZahl1.BackColor =

QBColor(5)10 TxtZahl1.ForeColor =

QBColor(15)11 TxtZahl1.FontSize = 1212 TxtZahl2.BackColor =


QBColor(15)14 TxtZahl2.FontSize = 1215 TxtZahl3.BackColor =


QBColor(15)17 TxtZahl3.FontSize = 1218 End Sub

Wichtig: Eingabefehler, wie z.B. Buchstabenwerden nicht abgefangen, ebenso keineNichts-Eingaben.

8 Verwende zunächst Zahlenwerte, bei denendu kalkulieren kannst, ob alle Berechnungeneinwandfrei ausgeführt werden., z.B. 100,100, 100 oder 200, 100, 100.

9 Schließlich drückst du wieder F5.

Grafik


49

Diagramme haben den Zweck, Werteanschaulich darzustellen. Manchmal erzeugt manmit sogenannte Säulendiagrammen den besserenEindruck. Wir wollen dem Anwender dieMöglichkeit geben, zwischen einer Säulen- undeiner Kreisdarstellung zu wählen.1. Zunächst speicherst du alles unter GRAFIK5.2. Als neuen Namen für das Objekt

CMDZEICHNEN wählst du CMDKREIS ...3. ... und gibst für CMDKREIS.CAPTION

Kreisdiagramm an.4. Dann änderst du die Prozedur

CMDZEICHNEN_CLICK in PRIVATE SUBKREISDIGRAMM() mit folgendem Code:

Private Sub KreisDiagramm() Dim x1 As Single, y1 As Single

Dim Radius As Single Dim Bogen As Single ::: ::: usw. :::

End Sub

5. Der Wert der Form.CAPTION ist GrafischeDarstellung von Werten

BefehlsschaltflächeNAME Name cmdSäule

CAPTION Beschriftung

Säulen-diagramm

5. Du doppelklickst auf cmdKreis und gibstfolgenden Code ein:

Private Sub cmdKreis_Click() picGrafik1.Cls KreisDiagramm

End Sub In dieser Prozedur wird mit der Methode CLS

der Inhalt des Bildfeldes gelöscht und dannangewiesen, die Prozedur KREISDIAGRAMMauszuführen, die unseren Code für dasZeichnen von Kreisdiagrammen enthält.

6. Endlich drückst du auf F5 Hast du alles richtig gemacht, müsste das

Programm ablaufen wie vorher.7. Nun doppelklickst du auf CMDSÄULE und

gibst folgenden Code ein:

Private Sub cmdSäule_Click() picGrafik1.Cls

End Sub Mit diesem Code wird das Bildfeld gelöscht.8. Dann drückst du ... genau: F59. Mit dem nachfolgenden Code wird ein

sogenannter Dummy eingesetzt: Private Sub SäulenDiagramm: picGrafik1.Print

"Hier sollen Säulen hin."

End Sub

10. ... und der übliche Druck auf F5 Klappt alles, wenn du ein Kreisdiagramm

erzeugst und dann auf die BefehlsschaltflächeSäulendiagramm klickst?

11. Du doppelklickst auf cmdSäule, ...12. ... ergänzt den Code wie folgt: Private Sub cmdSäule_Click()

picGrafik1.Cls SäulenDiagramm

End Sub

13. ... und drückst wieder einmal F5

Der Code in dieser Prozedur ist ein Dummy.Dummies kennst du als Puppen, die u.a. bei Auto-Crash-Tests eingesetzt werden. Mit diesemDummy probierst du aus, ob bis hierher allesklappt.

Es ist auf diese Art einfacher, Programmierfehlereinzugrenzen und zu korrigieren.

Nebenbei: du wirst in Visual Basic-Zeitschriftenoder Lehrbüchern immer wieder lesen, dass jedesProjekt vorher genau skizziert werden soll – undwenn du die Programmbeschreibung liest, denkstdu, du hast ein Genie vor dir: es ist alles imvorhinein bedacht worden. Niemand weiß vorherganz genau, welche Prozeduren entwickelt,welche Variablen deklariert werden müssen usw.Ein Unsinn ist auch, dem Leser vorzugaukeln,dass die ausgefeilte Bedienoberfläche zuerstentwickelt wurde. Der grobe Rahmen mussstehen, Feinheiten und neue Ideen ergeben sichunterwegs. Für Testläufe sind Dummies also einefeine Sache.

Grafik


50

Nun zu unseren Säulen. Der erste Vorschlag ist,einfach die Line-Methode mit dem Parameter B,bzw. BF zu verwenden .

1. Private Sub SäulenDiagramm()2. picGrafik1.Line

(100, 100)-(500, a), QBColor(5), BF

3. picGrafik1.Line (600, 100)-(1000, b), QBColor(4), BF

4. picGrafik1.Line (1100, 100)-(1500, c), QBColor(3), BF

5. End SubDie Prozedur ist selbsterklärend, hat abereindeutig große Nachteile. Zunächst einmal'hängen' die Säulen – das liegt daran, dass derKoordinaten-Nullpunkt in der linken oberenEcke liegt, zum anderen passen die Säulen beigroßen Werten nicht mehr in das Bildfeld.

Wir müssen einen kleinen Exkurs über 'virtuelleKoordinatensysteme' einlegen. Visual Basicermöglicht mit der Methode SCALE dieEinrichtung eigene Koordinatensysteme, wobeiauch andere Maßeinheiten eingesetzt werdenkönnen – so können z.B. anstatt Twips auch cmverwendet werden. Für uns ist interessant, dasswir den Koordinatenursprung verlegen können.Das Bildfeld hat über die Eigenschaften HEIGHTund WIDTH eine bestimmte Anzahl von Twips.Wir können aber auch sagen, dass das Bildfeldz.B. 1000 * 1000 Einheiten messen soll. DasBildfeld behält seine Twips, aber virtuell - alsokünstlich - können wir so tun, als gingen uns dieTwips nichts an. Wir können alle Methoden undOperationen auf der Grundlage 1000 * 1000durchführen. Das ist für Skalierungen sehrpraktisch, weil komplizierte Umrechnungenentfallen. Unsere virtuelle Skala oder dasSäulendiagramm werden durch Visual Basic vomkünstlichen zum normalen Zustand umgearbeitet.

1. Private Sub SäulenDiagramm()2. picGrafik1.Scale (0, picGrafik1.Height)-(picGrafik1.Width, 0)3. picGrafik1.DrawWidth = 24. picGrafik1.ForeColor = QBColor(0)5. 'waagerechte Skala6. picGrafik1.Line (250, 250)-(picGrafik1.Width - 500, 250)7. 'senkrechte Skala8. picGrafik1.Line (250, 250)-(250, picGrafik1.Height - 500)9. 'Säule a10. picGrafik1.Line (300, 250)-(800, a+250), QBColor(5), BF11. 'Säule b12. picGrafik1.Line (850, 250)-(1350, b+250), QBColor(4), BF13. 'Säule c14. picGrafik1.Line (1400, 250)-(1850, c+250), QBColor(3), BF15. End Sub

Für unseren Zweck legen wir die Null-Punkteder Koordinaten mit der Befehlszeile 2 in derobigen Prozedur in die linke untere Ecke undgeben ein virtuelles Koordinatensystem vonpicGrafik1.Height * picGrafik1.Widthvor, also die Höhe und Breite des Bildfeldes.Später werden wir eine andere Skalierungausprobieren.Der Code löst unser Problem zunächst einmal.Mit seiner Hilfe wird gewissermaßen diey-Achse in ihrer Richtung umgekehrt.Zu einem Säulendiagramm gehört eine Skala.Zeile 6 und Zeile 8 zeichnen die Linien. Dannwerden Rechtecke mit den Werten für die

Variablen a, b und c gezeichnet, wobei zu denWerten der Abstand der unteren Skala zumBildfeldrand addiert werden muss.. DieKoordinaten sind so abgemessen, dass sie nichtan den Rändern liegen. Welche Abstände manzwischen den Säulen vornimmt, bzw. welcheBreite die Säulen haben sollen, istGeschmackssache. Soll die Skala noch eineEinteilung und Beschriftungen bekommen,müssen die Abstände größer als hier sein.Verwende erst einmal die angegebenen Werteund probiere eigene Einstellungen.Du kannst jetzt zwischen dem Kreis- und demSäulendiagramm hin- und herschalten, neue

Grafik


51

Werte eingeben, auch während der Laufzeit dieWerte verändern usw.Damit die leidige Fehlermeldung und damit derProgrammabbruch bei leeren Textfeldernvermieden wird, setzen wir in die ProzedurenSÄULENDIAGRAMM und KREISDIAGRAMMfolgende Zeile ein:

On Error Resume NextDas bedeutet etwa: bei einem Fehler einfachweitermachen. Dieses Anweisung istgleichermaßen praktisch wie gefährlich, denndamit wird natürlich die Fehlersuche, dassogenannte DEBUGGING, sehr erschwert. Füreinfache, überschaubare Programme kann mandie Anweisung allerdings bedenkenlosverwenden.Nun speicherst du alles unter GRAFIK6.Zum Abschluss sollen noch Prozeduren für dasSpeichern und Laden der Werte eingefügtwerden. Die Bedeutung der einzelnenAnweisungen sind im Abschnitt Dateiverwaltungbeschrieben – wir wiederholen die beidenProzeduren noch einmal:

1. Private SubcmdSpeichern_Click()

2. Dim DateiNr As Integer3. Dim DateiName As String4. DateiName =

"C:\Coden\Zahlen.txt"

5. DateiNr = FreeFile6. Open DateiName For Output

As DateiNr7. Print #DateiNr, a, b, c8. Close9. End Sub

1. Private SubcmdÖffnen_Click()

2. Dim DateiNr As Integer

3. Dim DateiName As String

4. Dim Temp As String

5. DateiNr = FreeFile

6. DateiName ="C:\Coden\Zahlen.txt"

7. Open DateiName For InputAs DateiNr

8. Input #DateiNr, a, b, c

9. txtZahl1.Text = a

10. txtZahl2.Text = b

11. txtZahl3.Text = c

12. Close

13. End Sub

• Denke bei der Variablen DateiName daran,deinen eigenen Pfad zu verwenden.

Die beiden Diagramme haben folgendes Aussehen:

Simulationen


52

SimulationenComputer sind durch ihreRechengeschwindigkeit vorzüglich in der Lage,komplizierte Zusammenhänge schnell undübersichtlich darzustellen. Daher werden sie jaauch für sogenannte Hochrechnungen verwendet.Du kennst das sicherlich aus denWahlberichterstattungen – aus wenigenausgewählten Daten wird auf das Endergebnishochgerechnet – und zwar mit erstaunlicherGenauigkeit.Epidemie im AquariumIm folgenden Programm soll der Computer dieLebensqualität in einem Aquarium untersuchen.Angenommen, in einem Aquarium leben 1000Wasserflöhe. Diese Tiere vermehren sich miteiner bestimmten Vermehrungsrate, die aus derBiologie bekannt ist. Der Nachwuchs vermehrtsich, dessen Nachwuchs vermehrt sich usw.Ältere Tiere sterben. Auch die Lebenserwartungist bekannt, man weiß, wie alt Wasserflöhewerden.Nun kann man sich denken, dass die WasserflöheAbfallprodukte erzeugen, die das SystemAquarium belasten. Der Lebensraum wird alsozusehends vergiftet.Wie wirkt sich dieser Sachverhalt auf denLebensraum aus und wie auf dieLebewesenanzahl?Der Computer soll in einer Tabelle dieEntwicklung darstellen.GrundannahmenEs müssen einige Grundannahmen gemachtwerden. Wir unterstellen eine Vermehrungsratevon 0, 3 Punkten und eine Sterberate von 0, 2.Diese Werte haben sich in der Biologie alsannähernd realistisch herausgestellt. Im übrigengeht es um das Prinzip, nicht um neuewissenschaftliche Erkenntnisse. AlsVergiftungsrate nehmen wir 0, 05 an; dadurchwird der Vergiftungsfaktor 0, 00005 ( das hängtvon der Wasserqualität ab).Die Gleichungen habe ich aus Biologiebüchernübernommen und computergerecht umgesetzt.Es gibt also folgende Variablen:

WASSERFLÖHE = 1000VERMEHRUNGSRATE = 0, 3STERBERATE = 0, 2ABFALLPRODUKTE = 0 (zu Beginn des

Systems sind ja nochkeine vorhanden)

VERGIFTUNGSFAKTOR = 0,00005VERGIFTUNGSRATE = 0, 05

Mathematisch ausgedrückt müssenGleichungssysteme programmiert werden. FürMathematiker: die Grundlage sindDifferentialgleichungen.1. Sterberate = Sterberate +

Vergiftungsfaktor *Abfallprodukte

2. Wasserflöhe = Wasserflöhe +(Vermehrungsrate - Sterberate)* Wasserflöhe

3. Abfallprodukte =Abfallprodukte +Vergiftungsrate * Wasserflöhe

Die Gleichungen müssen in dieser Reihenfolgegeschrieben werden, weil die errechneten Wertein der nächsten Gleichung eingesetzt werden.Code1. In der FORM gibst du etwa 6300 * 6300

Twips ein und als CAPTION Wasserflöhe.2. Dann erstellst du eine BEFEHLSSCHALT-

FLÄCHE:NAME Name cmdStart

CAPTION Beschriftung &Start

3. Du deklarierst die Variablen im Allgemeinteildes nachfolgenden Code:1 Option Explicit2 Dim Wasserflöhe As Single3 Dim Vermehrungsrate As

Single4 Dim Sterberate As Single5 Dim Abfallprodukte As Single6 Dim Vergiftungsfaktor As

Single

Simulationen


53

7 Dim Vergiftungsrate AsSingle

8 Dim Generationen as Integer

4. In der Prozedur FORM_LOAD weist du denVariablen die nachfolgenden Werte zu:1 Private Sub Form_Load()

2 Wasserflöhe = 1000

3 Vermehrungsrate = 0.3

4 Sterberate = 0.2

5 Abfallprodukte = 0

6 Vergiftungsfaktor = 0.00005

7 Vergiftungsrate = 0.05

8 End Sub

5. Dann doppelklickst du auf Start und setzt folgenden Code ein:1 Private Sub cmdStart_Click()2 Print "Generationen", "Anzahl der", "Sterberate",

"Abfallprodukte"3 Print , "Wasserflöhe"4 Print Generationen, Wasserflöhe, Sterberate, Abfallprodukte5 Do While Int(Wasserflöhe) > 06 Generationen = Generationen + 17 Sterberate = Sterberate + Vergiftungsfaktor * Abfallprodukte8 Wasserflöhe = Wasserflöhe + (Vermehrungsrate - Sterberate) *

Wasserflöhe9 Abfallprodukte = Abfallprodukte + Vergiftungsrate *

Wasserflöhe10 Print Generationen, Int(Wasserflöhe), Int(10 * Sterberate) /

10, Int(Abfallprodukte)11 Loop12 End Sub

6. In einer sehr unprofessionellen Form werdendie Werte durch die PRINT-Methode einfachauf der Form dargestellt. Das hat aber denVorteil, dass man erst einmal sehen kann, obdie Berechnungen stimmen.

7. Zeile 2 und 3 sind für die Titel der Listen da.In Zeile 3 musst du darauf achten, dass dasKomma nicht übersehen wird. Es istgewissermaßen ein Tabulator und schreibtden Wert Wasserflöhe an die nächsteTabulatorstelle. In Zeile 4 werden dieStartwerte der Variablen geschrieben, weil inder Schleife schon die nächste Berechnungerfolgt.

8. Zwischen Zeilen 5 und 11 wird eine Schleifeso lange wiederholt, wie der Wert derVariablen Wasserflöhe größer als Null ist.Dabei wird die Zahl der Generationen in Zeile6 hochgezählt.

9. Die Zeilen 7–9 sind die Berechnungsformeln,die du nicht unbedingt verstehen musst.

10. In Zeile 10 werden die errechneten Werte aufdie Form geschrieben, wobei du dieAnweisungInt(10 * Sterberate) / 10beachten solltest. Dadurch wird eineDarstellung der Dezimalzahl auf eine Stellenach dem Komma beschränkt, wobei das Auf-und Abrunden mathematisch einwandfreiausgeführt wird.

Int(100 * Sterberate) / 100ergibt eine zweistellige Dezimalzahl.

11. Nun drückst du auf F5 ...12. ... und klickst auf CMDSTART.

Simulationen


54

Die Form sollte die folgenden Zahlenreihenaufweisen:

InterpretationZunächst vermehren sich die Wasserflöhe, dieSterberate bleibt annähernd gleich, aber dieAbfallprodukte nehmen zu. In der 10. Generationkippt das System bis hin zum totalenZusammenbruch in der 24. Generation.Du setzt den Wert der Variablen VERGIFTUNGS-FAKTOR auf 0.00002. und drückst auf F5Damit hast du die Lebensqualität derWasserflöhe verbessert; es könnte dieWasserqualität sein, aber auch das Futter.Immerhin bricht das System erst in der 32.Generation zusammen.Viel aussagekräftiger als diese Zahlenreihen sindgrafische Darstellungen. Dafür reicht leider derPlatz nicht.

Anhang


55

AnhangSuffixe für SteuerelementeEmpfehlungen für Namen (Steuerelemente)cmd Befehlsschaltfläche

(Command)frm Form

pic Bildfeld (Picture)lbl Bezeichnungsfeld (Label)fra Rahmenfeld (Frame)txt Textfeld (Textbox)shp Figurenelement (Shape)

Text mit Zeichenketten-Funktionenumkehren1. Du erstellst die Befehlsschaltfläche

CMDENDE, ...2. ... dann die Befehlsschaltfläche

CMDUMWANDELN.3. Dann folgt das Textfeld TXTEINGABE ...4. ... und das Textfeld TXTAUSGABE. Der Code lautet:

I. Umwandeln Option Explicit

II. Private SubcmdEnde_Click()

III. EndIV. End Sub V. Private Sub

cmdUmwandeln_Click()VI. Dim ursprung As StringVII. Dim temp As StringVIII. Dim i As IntegerIX. ursprung =

txtEingabe.TextX. temp = ursprungXI. For i = 1 To

Len(ursprung)XII. Mid$(ursprung, i, 1) =

Mid$ _ (temp, (Len(temp) - i) + 1,1)

XIII. Next iXIV. txtAusgabe.Text =

ursprung5. End Sub

6. Dann drückst au auf F5...7. ... gibst den Text ein und siehst UMWANDELN.

Du kannst dir das Programm für deineAnwendungen abkupfern. Es geht hier nichtdarum, dass es bessere Lösungen gibt, sondernum die Zeichenkettenverarbeitung.FunktionDie Formel für die Berechnung derMehrwertsteuer ist bei einem MWS-Satz von16%Steuer = Betrag * 16 / 100Du legst die Bezeichnungsfelder wie im Bild an.

Die Namen sind: LBLBETRAG, LBLMWS,LBLGESAMTBETRAG

Dann erstellst du die BefehlsschaltflächeCMDENDE

Anhang


56

Der Code lautet:Option Explicit

Dim Steuer As Currency

Private Sub Form_Load()

Dim Betrag As Currency

Betrag=InputBox("Betrag eingeben", "Mehrwertsteuer- Berechnung")

MehrwertSteuer (Betrag)

lblBetrag.Caption = Betrag & " DM "

lblMws.Caption = Steuer & " DM "

lblGesamtbetrag.Caption = Betrag + Steuer & " DM "

End Sub

Private FunctionMehrwertSteuer(Betrag) As Currency

Steuer = Betrag * 16 / 100

End Function

Private Sub cmdEnde_Click()

End

End Sub

Zeichenkette umkehren mit Funktion• Textfeld txtEingabe• Textfeld txtAusgabe• Befehlsschaltfläche cmdUmkehren• Befehlsschaltfläche cmdEnde• Bezeichnungsfelder• cmdUmkehren.Default = True (damit kann

auch durch EINGABE 'umgekehrt' werden.

Der Code lautet:1. Private Sub

cmdUmkehren_Click()2. Dim Text As String3. Text = txtEingabe.Text4. Rückwärts (Text)5. txtAusgabe.Text =

Rückwärts(Text)6. End Sub

In Zeile 3 wird der Inhalt des EINGABE-Textfensters in der Variablen TEXT abgelegt.Dann wird die Funktion aufgerufen und dabei dieVariable als Wert übergeben. In dernachfolgenden wird die Variable in der For-Next-Schleife, Zeilen 4 - 6 verarbeitet, indem sievon hinten nach vorn eingelesen wird. Dieeinzelnen Zeichen werden in einer HilfsvariablenTemp gespeichert, deren Wert alsFunktionsergebnis zurückgegeben und imAusgabefenster angezeigt wird.

1. Private FunctionRückwärts(a) As String

2. Dim i As Integer3. Dim Temp As String4. For i = Len(a) To 1 Step-15. Temp = Temp + Mid(a, i,

1)6. Next7. Rückwärts = Temp8. End Function

Anhang


57

Eingabe-Dialogfeld (Input-Box)Für einfache Eingaben in Programme stelltVisual Basic ein Eingabe-Dialogfeld zurVerfügung. Die Input-Box zeigt ein Fenster miteiner Eingabeaufforderung an und erwartet ineinem Textfeld eine Eingabe. Der Text, es kannauch eine Zahl sein, wird an das Programmzurückgegeben und ausgewertet.Ich verwende die Input-Box fast ausschließlichfür das schnelle testen von Eingaben, bevor icheine andere Methode programmiere.1. Private Sub Form_Load()2. Dim Frage As String, Titel As

String3. Dim Vorgabe As Integer4. Dim Bewertung As Integer5. Frage = "Wie alt bist du?"6. Titel = "Altersabfrage"7. Vorgabe = 1008. Bewertung = InputBox(Frage,

Titel, Vorgabe, 200, 200)9. Select Case Bewertung10. Case Is < 2011. lblBewertung.Caption =

"Ganz schön jung!"12. Case 21 To 2913. lblBewertung.Caption = "Du

bist ein Zwanziger" Case 30To 39

14. lblBewertung.Caption = "Dubist ein Dreissiger"

15. Case Is > 4016. lblBewertung.Caption =

"Ganz schön alt!"17. End Select18. End Sub

In diesem Listing werden die Variablendeklariert und mit Werten belegt. Dann wird derVariablen Bewertung das Ergebnis der Input-Box-Funktion übergeben und in einerSELECT/CASE-Anweisung überprüft. DasErgebnis der Auswertung wird in einemAnzeigefeld als CAPTION angezeigt.Fehler werden in diesem Beispiel nichtabgefangen. Solltest du also Buchstabeneingeben, steigt das Programm mit einerFehlermeldung aus, denn die VariableBewertung wurde als Integer deklariert.Willst du Texteingaben überprüfen, z.B. Namen,musst du das Programm nur etwas umschreiben. Sokönntest du dir einen kleinen Schutzcode für einProgramm schreiben, der erst nach der Eingabe einesrichtigen Codewortes den Start des Programmsermöglicht.

Stichwort


58

-, 40Anfasser, 7Anweisung, 10; 13Apostroph, 25Array, 35Aspekt, 46Bedingungsschleife, 31Befehle, 10Bogenmaß, 47BorderColor, 43BorderStyle, 33; 43BorderWidth, 43Byte, 21Circle, 42; 45Click-Ereignisse, 27Cls, 42Code, 7Const, 11ControlBox, 33Debug.Print, 37Debugging, 52Dim, 11Do-Schleife, 32Dummy, 50Edition, 5Eigenschaften, 7ElseIf, 29End If, 29End Sub, 15Entwicklungsphase, 7Entwicklungszeit, 44EOF, 32Ereignis, 14ereignisorientiert, 14EXE, 9Exit Sub, 28false, 12Fester Dialog, 33Figur, 17FillColor, 46FillStyle, 46Form, 7Formular, 8Frame, 33FreeFile, 32GDI-Funktionen, 42gleich, 22Gradmaß, 47Grafik-Steuerelemente, 42gruppieren, 17größer als, 22

If/Then-Struktur, 29Index, 35Int, 20Ja/Nein-Entscheidung, 29Kaufmännisch Und, 35Kennung, 18kleiner als, 22Kommentarzeichen, 25Konstante, Visual Basic-, 27Koordinatensysteme, 51KreisDiagramm, 50Kreiszahl, 47Label, 33Laufzeit, 7; 44Line, 42Line Input, 32Load, 39Load', 14Me, 43MsgBox, 26Objekt, 14Objektliste, 7objektorientiert, 14Pi, 47PictureBox, 16Platzhalter, 10Point, 42Print, 40; 42Private, 15Program-Listing, 17Projektfenster, 6Prozedur, 25Pset, 42Punkteraster, 9Radius, 46Rahmenfeld, 33Randomize, 20Rechteck, 45RGB, 45Rnd, 20Scale, 51Select/Case, 29SendKeys, 49Shape, 16Single, 20Skalierung, 51Sprungmarke, 28Standardoperatoren, 12String, 11Sub, 15Temp, 32

Term, 27Tools, 8Tooltip, 7true, 12Twip, 43ungleich, 22Unload, 40Variablendeklaration, 11Variablenfeld, 35Variablentypen, 10Version, 5Visual Basic-Konstante, 27Wend, 30Werte, 7While-Wend, 30x-Achse, 43y-Achse, 43Zeichenkette, 11; 13'Zufallsgenerator', 35zufall, 20Zufallszahl, 35Zählschleife, 31

visual basic - · pdf filevisual basic 6.0 bei. zitat aus der readme-datei: das verzeichnis...

Documents