Cursus Programmeren in QuickBasic 4.5

C U R S U S C U R S U S C U R S U S C U R S U S
P R O G R A M M E R E N IN

Q u i c k B A S I C
versie 4.5

voor beginners

M.J.W. Beck

Beginnerscursus programmeren in QuickBASIC
M.J.W. Beck, 1993 2013

Niets uit deze uitgave mag openbaar gemaakt worden zonder
toestemming van de auteur (mjwbeck_at_hotmail.com)

1

INHOUDSOPGAVE

VOORWOORD 2

1 WAT IS PROGRAMMEREN? 3

2 DE QuickBASIC PROGRAMMEEROMGEVING 4

3 UITVOER NAAR HET SCHERM 6

4 VARIABELEN (1): GETALVARIABELEN 8

5 VARIABELEN (2): STRINGVARIABELEN 11

6 VARIABELEN (3): ARRAYVARIABELEN 14

7 GEGEVENS INVOEREN (1) 16

8 ZELF PROGRAMMA'S MAKEN (1) 17

9 BESLISSINGSSTRUCTUREN (1): IF...THEN...ELSE 18

10 BESLISSINGSSTRUCTUREN (2): SELECT CASE 21

11 HET GEBRUIK VAN HET TOETSENBORD IN PROGRAMMA'S 23

12 LUSSEN (1): FOR...NEXT 27

13 LUSSEN (2): DO...LOOP EN WHILE...WEND 32

14 GEGEVENS INVOEREN (2) 36

15 HET LEZEN VAN EN HET SCHRIJVEN NAAR EEN BESTAND OP DE SCHIJF 37


17 GRAFISCHE MOGELIJKHEDEN (1): INLEIDING EN LIJNEN 44

18 GRAFISCHE MOGELIJKHEDEN (2): PSET 46

19 GRAFISCHE MOGELIJKHEDEN (3): DRAW 48

20 GRAFISCHE MOGELIJKHEDEN (4): CIRKELS EN ELLIPSEN 50


2

VOORWOORD VOORWOORD VOORWOORD VOORWOORD

De beginnerscursus QuickBASIC is oorspronkelijk in 1993 geschreven voor
leerlingen op een school voor voortgezet onderwijs. Het doel was om de
leerlingen te interesseren voor het programmeren en dat zij er plezier in
zouden krijgen en het als een uitdaging zouden zien om programma's te maken
in QuickBASIC.

Anno 2013, dus 20 jaar later(!), is de cursus herzien. Het doel is nog steeds
om de belangstelling van de lezer te wekken voor het programmeren, ook al
gebeurt dit in een DOS-omgeving. De opzet van de cursus is hetzelfde gebleven,
maar wat achterhaald is, zoals werken met floppydisks, guldens en dergelijke
is aangepast.

Deze handleiding speelt een centrale rol in de cursus. Zij is met de grootste
zorg samengesteld, waarbij uitgegaan wordt van het principe dat je met de
handleiding en de PC voor je aan de slag moet kunnen gaan. Daarom staan er
ook zo veel voorbeeldprogramma's in, waarin iedere keer een bepaald aspect
van het programmeren wordt toegelicht. Alle programma's zijn uiteraard op hun
juistheid gecontroleerd.

Van alleen maar het intypen van voorbeeldprogramma's leer je niet veel. Bij
veel programma's staan opdrachten. Je moet dan bijvoorbeeld in het programma
iets wijzigen en kijken wat dit voor effect heeft. In aparte hoofdstukken staan
ook programmeeropdrachten. Wat je in de voorgaande hoofdstukken geleerd hebt,
moet je dan kunnen toepassen in zelf te schrijven programma's. Uiteraard
begint dit vrij eenvoudig.

M.J.W. Beck, juli-augustus 1993 (herzien augustus 2013)

3

HOOFDSTUK 1 HOOFDSTUK 1 HOOFDSTUK 1 HOOFDSTUK 1 WAT IS PROGRAMMEREN? WAT IS PROGRAMMEREN? WAT IS PROGRAMMEREN? WAT IS PROGRAMMEREN?

In feite is programmeren niets anders dan de computer een serie opdrachten
geven. Een opdracht als: "Bereken het gemiddelde van 5 + 8" begrijpt de PC
niet. Hij kan alleen opdrachten uitvoeren die in 'machinetaal' zijn gegeven.
Het kost veel tijd om een programma in machinetaal te schrijven. Om die reden
werden er vertaalprogramma's (interpreters) geschreven. Hiermee kun je de
opdrachten (veel minder dan in een machinetaalprogramma) in normaal Engels
invoeren, waarna het automatisch voor je vertaald wordt in machinetaal. De
eenvoudigste van de interpreters is BASIC (Beginners All-purpose Symbolic
Instruction Code). Deze programmeertaal werd in 1965 ontwikkeld en is daarna
sterk verbeterd en uitgebreid. In deze cursus wordt gewerkt met QuickBASIC
Versie 4.5.

HOE ZIET NOU ZO'N BASIC-PROGRAMMA ER UIT?
Hieronder een voorbeeld van een programma dat tafels berekent.

REM Berekenen van tafels
CLS
INPUT " Tafel van ", T
PRINT STRING$(16, "=")
FOR I = 1 TO 20
PRINT USING "## x ### = ####"; I; T; I * T
NEXT I
END

Op iedere regel staat een opdracht. Als je dit programma aandachtig bekijkt,
snap je misschien wel wat er precies gebeurt. Er wordt nu geen uitleg bij
gegeven, want later wordt op dit programma teruggekomen. Je zult zien dat als
je later nog eens naar dit programma kijkt, je direct begrijpt wat er staat.

Het zal duidelijk zijn dat je de opdrachten in een logische volgorde plaatst.
Als je geen geld op zak hebt, ga je eerst geld halen bij de bank en dan pas
boodschappen doen en niet andersom. Als je in een programma de opdrachten
omdraait of verkeerde opdrachten geeft, werkt het programma niet. Hoe je die
fouten (die door iedereen worden gemaakt) kunt opsporen en verhelpen leer je
natuurlijk ook.

NU WIL IK AAN DE SLAG M'N EERSTE PROGRAMMA?
Voor het programmeren in QuickBASIC heb je het programma QB.EXE nodig. De
benodigde bestanden, inclusief mappen met voorbeeldprogrammas, zijn te
vinden op: https://www.dropbox.com/sh/ie1xyo1qdezmr20/RrsKplTPTk.
(indien niet, stuur dan een mail naar mjwbeck_at_hotmail.com).
De programmas uit deze cursus staan in de map CURSUS.
Hoofdstuk 2 gaat over de werking van het programma QB.EXE. Als dit duidelijk
is, kun je programma's gaan maken.

4

HOOFDSTUK 2 DE Q HOOFDSTUK 2 DE Q HOOFDSTUK 2 DE Q HOOFDSTUK 2 DE Quick uick uick uickBASIC PROGRAMMEEROMGEVING BASIC PROGRAMMEEROMGEVING BASIC PROGRAMMEEROMGEVING BASIC PROGRAMMEEROMGEVING

WE GAAN BEGINNEN
Het gebruik van speciale toetsen wordt weergegeven met < >. Als je bijvoorbeeld
op de toets Home moet drukken staat er <Home>. In DOS (Disk Operating System,
de voorloper van Windows) en in QuickBASIC moet je na iedere regel op <Enter>
drukken. Het drukken op <Enter> wordt niet steeds aangegeven.

QuickBASIC werkt het beste in een DOS-omgeving. Hiervoor kan het gratis
programma DosBox worden gedownload op http://www.dosbox.com. Als DosBox
gestart is en QB.EXE staat in de map C:\QB45, dan kun je als volgt QuickBASIC
starten in de DOS-omgeving van DosBox:
mount c c:\qb45
c:
qb
QuickBASIC is nu gestart en waarschijnlijk in een venster. Met <ALT><Enter>
kun je omschakelen naar een volledig scherm.

WAT IS DIT NU?
Wat nu op het scherm staat noemen we het HOOFDSCHERM. Op de bovenste regel
zie je de woorden File, Edit, View etc. staan. Dit zijn allemaal verschillende
menu's die je kunt activeren door de ALT-toets ingedrukt te houden en dan de
eerste letter van het woord in te typen. Je kunt ook de linker muisknop
gebruiken.

Om hiermee te oefenen kun je het File-menu activeren. Er verschijnt dan een
menu met de woorden New Program, Open Program etc. Bovendien staat New Program
in een blokje. De opties die je nu ziet kun je op twee manieren activeren met
het toetsenbord:
1. Typ de anders gekleurde letter in.
2. Beweeg het blokje met de pijltjestoetsen (of cursortoetsen) op en neer
totdat de gewenste optie in het blokje staat en druk op de Entertoets.
Als je met de cursortoetsen alle opties doorloopt, zie je op de onderste regel
wat je met deze optie kunt doen. Helemaal links onderaan staat dat je met F1
hulp kunt krijgen.
Ook nu kun je de opties in de submenu's ook activeren met de linker muisknop.
Met <Esc> kun je een opgeroepen menu weer laten verdwijnen.

HET HERSTELLEN VAN TYPEFOUTEN TIJDENS HET PROGRAMMEREN?
Dit gaat hetzelfde als in Word, Excel en dergelijke. Er is n belangrijk
verschil: de toetscombinaties voor het kopiren, verwijderen en plakken van
tekst is hier anders. Je vindt deze toetscombinaties in het menu onder Edit.

Als de opdrachten intypt die QuickBASIC herkent, dan worden ze automatisch
in hoofdletters weergegeven. Als je bijvoorbeeld 'rem' intypt gevolgd door
<Enter>, dan staat er 'REM' in het scherm. Hiermee kun je commentaar bij de
regels plaatsen; dit kan ook met '.
Maak je een typefout en typ je 'ram' in, dan zie je ook 'ram' in het scherm
staan. QuickBASIC denkt nu dat je een variabele bedoelt met de naam 'ram'.

Fouten in de programmeeropdrachten herkent QuickBASIC, maar je wordt er pas
op geattendeerd als je het programma start. Dit kan met <F5> of met
<Shift><F5>.

5

OEFENPROGRAMMA
Voer de onderstaande opdrachten uit (<Enter> wordt niet aangegeven):
Typ CLS
Typ PRINT gevolgd door een spatie en dan een zinnetje, bijvoorbeeld "ik
heet ...", vergeet daarbij de aanhalingstekens niet.
Typ ? en weer gevolgd door een spatie en hetzelfde zinnetje.
Herhaal dit een aantal maal (dat kan door alles in te typen, maar ook door
de tekst te kopiren en te plakken)
Typ END
Druk nu op <F5>.

Als het goed is staat nu op het scherm een aantal keer het zinnetje dat je
hebt ingetypt. Je hebt de volgende opdrachten gebruikt:
CLS om het scherm schoon te maken (CLear Screen)
PRINT (of ?) om iets op het scherm te zetten (tekst moet dan tussen
aanhalingstekens staan)
END om het programma te beindigen.

Onder in beeld staat: Press any key to continue
Druk op een willekeurige toets (je komt nu weer terug in het hoofdscherm).
Druk nu een paar keer op <F4> (Hiermee wissel je tussen de twee schermen).

In programmas komen vaak opdrachten voor die herhaald moeten worden. Hiervoor
zijn lussen bedacht. Het zojuist gemaakte programma zou je als volgt kunnen
aanpassen:
CLS
FOR i = 1 to 10
PRINT Ik heet
NEXT i
END

Typ het programma in en druk op <F5>.

De opdrachten FOR en NEXT horen bij elkaar en vormen een lus. De lus wordt
10 keer uitgevoerd. Het inspringen van de opdracht PRINT is niet noodzakelijk,
maar vergroot de overzichtelijkheid in grotere programmas. Alle ingesprongen
tekst hoort bij een speciale opdracht, bijvoorbeeld een lus (zie hoofdstuk
12 en 13) of een beslissingsstructuur (zie hoofdstuk 9 en 10)

EEN BESTAND BEWAREN OP DE SCHIJF
Er staan veel programma's in deze cursus. De meesten zijn slechts bedoeld als
toelichting bij een bepaald commando. Je mag zelf bepalen of je de programma's
op een schijf wilt bewaren of niet. Een programma kun je opslaan via het File-
menu. Kies dan de optie Save (met de muis of S intypen).
Er verschijnt nu een nieuw scherm. Bovenin kun je de naam van het programma
invoeren (maximaal 8 letters). Deze naam eindigt automatisch met .BAS. Sla
het programma op in de map EXAMPLES.

EEN BESTAND OPENEN
Als je een programma wilt uitvoeren dat op de schijf staat, moet je het eerst
openen. Dat gaat via het File-menu en de optie Open Program. Er verschijnt
dan een scherm met een overzicht van alle BASIC-programma's. Zoek eventueel
naar de juiste map. Als je het gewenste programma hebt gevonden kun je het
openen door er 2x kort achter elkaar met de muis op te klikken (of druk er
1x op met de muis gevolgd door <Enter>). Een eventueel vorig programma wordt
nu automatisch gewist (als het nog niet opgeslagen is, wordt eerst gevraagd
of het bewaard moet worden) en het geselecteerde programma wordt geladen.
6

HO HO HO HOO OO OFDST FDST FDST FDSTU UU UK 3 K 3 K 3 K 3 UITV UITV UITV UITVO OO OER N ER N ER N ER NAA AA AA AAR R R R H HH HET ET ET ET SCH SCH SCH SCHERM ERM ERM ERM

HOE DE UITVOER UITVOEREN?
Hieronder staan een paar eenvoudige programma's die bedoeld zijn om de werking
van bepaalde commando's (zoals PRINT) toe te lichten. Voordat je de regels
intypt, moet je met <Alt><F> en New Program voor een schoon scherm zorgen.
Op de vraag of het programma bewaard moet worden, kies je <No>. De programma's
start je met <F5> of <Shift><F5>.

Bij sommige regels wordt toelichting gegeven. Dit commentaar staat dan aan
het eind van de regel en begint met '. Dan weet QuickBASIC dat er gewone tekst
volgt. Je hoeft dit commentaar niet per se over te nemen. Je kunt de commando's
die in hoofdletters staan gewoon met kleine letters intypen.

Opmerking: Ter onderscheid van de hoofdletter O en het cijfer nul, wordt de
nul als volgt aangegeven: 0.

3.1 De commando's PRINT, LOCATE en TAB() 3.1 De commando's PRINT, LOCATE en TAB() 3.1 De commando's PRINT, LOCATE en TAB() 3.1 De commando's PRINT, LOCATE en TAB()
CLS 'maakt het scherm schoon
PRINT "Ik programmeer in QuickBASIC" 'LET OP de aanhalingstekens
PRINT "1934"
PRINT TAB(12); 1934 'begint op positie 12
PRINT Hallo
LOCATE 1, 40
PRINT "Dit staat op regel 1, positie 40"
LOCATE 12, 70 'regel 12, positie 70
PRINT 2+3
LOCATE , 70
PRINT 2*3
END

Toelichting bij programma 3.1
Bij PRINT wordt gewone tekst tussen aanhalingstekens gezet: PRINT "tekst".
Als er geen aanhalingstekens staan wordt de waarde van een variabele getoond
of het resultaat van een berekening. Een variabele is hetzelfde als de X in
de wiskunde. In BASIC kunnen variabelen ook uit meer letters bestaan. Hierover
later veel meer.
Na PRINT Hallo wordt er op het scherm een 0 gezet, want met Hallo wordt
hier een variabele bedoeld en die heeft de waarde 0.
Bij berekeningen wordt * gebruikt als vermenigvuldigingsteken.
Met LOCATE geef je aan waar iets op het scherm moet komen te staan. Helemaal
linksboven is LOCATE 1,1. Helemaal rechts beneden is LOCATE 25,80.
Met TAB() kun je alleen de positie op de regel aangeven waar het printen moet
beginnen (met printer wordt hier steeds het weergeven op het scherm bedoeld).
Het programma wordt afgesloten met END. Na deze opdracht stopt het programma
onherroepelijk. Een programma dat met END begint, zal dus nooit uit te voeren
zijn.

In programma 3.2 zul je zien dat je met de PRINT-opdracht meerdere gegevens
op het scherm kunt krijgen.

PROBEER STEEDS TE BEGRIJPEN WAT JE DOET!!
7

3.2 Nogmaals het commando PRINT 3.2 Nogmaals het commando PRINT 3.2 Nogmaals het commando PRINT 3.2 Nogmaals het commando PRINT
CLS
PRINT A + B
PRINT "A + B"
PRINT "A" + "B"
PRINT 1; 2; 3; 4
PRINT 1, 2, 3, 4
PRINT "A"; "B"; "C"
PRINT "D", "E", "F"
PRINT "x = "; (3 + 4 / 5) + (1 / 3 * SQR(9))
LOCATE 24, 1
PRINT "Zonder ; aan het eind verspringt het beeld!";
END

Met ; aan het eind van een PRINT-opdracht voorkom je dat er automatisch naar
de volgende regel wordt gesprongen. Er wordt dan geen Carriage Return (=
<Enter>) gegeven. Op die manier kun je afzonderlijke dingen achter elkaar
plaatsen. Let op het verschil tussen ; en , in het gebruik.
Met SQR(9) wordt bedoeld: de wortel van 9 (wortel = SQuare Root).

SLAPEN MET GELUID EN KLEUREN.
3.3 De commando's COLOR, BEEP, SOUND en SLEEP 3.3 De commando's COLOR, BEEP, SOUND en SLEEP 3.3 De commando's COLOR, BEEP, SOUND en SLEEP 3.3 De commando's COLOR, BEEP, SOUND en SLEEP
CLS
PRINT "Wacht 2 seconden op een toon."
SLEEP 2
BEEP
SLEEP 1: COLOR 16, 7 'voor- en achtergrondkleur veranderen
PRINT "A L A R M ! ! ! "
SOUND 300, 10: SOUND 400, 10: SOUND 800, 10
SLEEP 4
COLOR 7, 0
CLS
PRINT "Alles weer normaal!"
PRINT "Alleen m'n ogen ";
COLOR 31 'alleen voorgrondkleur veranderen
PRINT "knipperen";
COLOR 7
PRINT " nog."
END

Met SOUND kun je een bepaalde toon met de frequentie in Herz (eerste getal)
een zekere tijd (tweede getal) laten horen. Hier duurt de toon
10
/18
e
seconde.
Verschillende commando's mogen ook op n regel staan, mits ze gescheiden zijn
door een dubbele punt. Vaak is het overzichtelijker als je n commando per
regel gebruikt.
Met COLOR kun je de voor- en achtergrondkleur veranderen. De achtergrondkleur
loopt van 0 t/m 7. Geen achtergrondkleur aangeven betekent automatisch kleur
0 (= zwart). De voorgrondkleur loopt van 0 t/m 31. Van 8 t/m 15 zijn het fellere
kleuren. Daarna wordt het patroon herhaald, maar dan knipperend.

LET OP! Een COLOR-opdracht geldt voor ALLE volgende PRINT-opdrachten.

8

H HH HOO OO OO OOFDST FDST FDST FDSTU UU UK 4 K 4 K 4 K 4 VARIABELEN VARIABELEN VARIABELEN VARIABELEN (1): GET (1): GET (1): GET (1): GETALVARIABELEN ALVARIABELEN ALVARIABELEN ALVARIABELEN

Er zijn twee soorten variabelen: GETALVARIABELEN en STRINGVARIABELEN. Beide
soorten kunnen ook gebruikt worden in een zogenaamde ARRAY-variabele. In
de hoofdstukken 4, 5 en 6 worden deze variabelen behandeld. Er zijn ook nog
variabelen die je zelf kun definiren, maar dit is voor gevorderden.

GETALVARIABELEN
Dit zal het meest bekend zijn, want in de wiskunde werk je ook met getal-
variabelen. Als je opschrijft: x = 3, dan heeft x de waarde 3. Hier is x een
getalvariabele. Je kunt dus aan x een waarde toekennen. Dat kan ook via een
berekening: x = 3*5 + 2.5. Na deze opdracht heeft x de waarde 17.5 (LET OP:
er wordt bij decimale getallen een punt gebruikt in plaats van de komma).

In BASIC kunnen de variabelen uit meer letters (en ook cijfers) bestaan.
Maximaal zijn 40 tekens toegestaan, maar je moet altijd met een letter
beginnen.
Juist zijn dus: Hallo, Winst, Getal1, Getal2, Cijfer, x, Oeroeboeroe. Bij
het toekennen van een waarde MOET de variabele VOOR de = staan.

De volgende toekenningen zijn juist in BASIC:
Breuk = 4 / 8 Breuk krijgt de waarde 0.5
X = SIN(2*a) De sinus van 2a wordt berekend
tel = tel + 1 tel wordt 1 groter
zero = 0 zero krijgt de waarde 0

De volgende toekenningen zijn onjuist in BASIC:
A + B = 23
X > 2
SIN(x) = 0.345

Hieronder staan programma om te oefenen. Begin iedere keer met New Program.
Typ het programma in en voer het uit met <Shift><F5>.

4.1 Getalvariabelen en berekeningen (1) 4.1 Getalvariabelen en berekeningen (1) 4.1 Getalvariabelen en berekeningen (1) 4.1 Getalvariabelen en berekeningen (1)
CLS 'scherm schoonmaken
A = 3: B = 4: C = 5.6: D = 7.2 'beginwaarden toekennen aan variabelen
PRINT A * B * C 'product A*B*C op scherm tonen
Product = A * B * C 'berekening uitvoeren
PRINT Product 'resultaat (= 67.2) op scherm tonen
PRINT "Product = "; Product 'idem met tekst erbij
Gem = (A + B + C + D) / 4 'bereken gemiddelde
LOCATE 20, 1 'ga naar regel 20, positie 1
COLOR 0, 7 'zwarte tekst op witte achtergrond
PRINT "Gemiddelde: ";
COLOR 7, 0 'witte tekst op zwarte achtergrond
PRINT Gem 'op scherm: Gemiddelde: 4.95
LOCATE 15, 1 'ga naar regel 15, positie 1
PRINT SQR(D) 'wortel van 7.2 tonen (2.68328...)
X = (A + B) * C / D 'bereken X
PRINT X 'resultaat op scherm (5.44444...)
END

9

4.2 Getalvariabelen en berekeningen (2) 4.2 Getalvariabelen en berekeningen (2) 4.2 Getalvariabelen en berekeningen (2) 4.2 Getalvariabelen en berekeningen (2)
CLS
X = 2 / (SQR(5) - 1) 'bereken X
PRINT 1 / X, X, X ^ 2 'alles op regel; X^2 = X*X
X = X + 1 'X wordt 1 groter
PRINT X
Y = ABS (-4.34) 'absolute waarde: Y = + 4.34
Z = SIN(1 / X) ^ Y 'SIN = sinus
PRINT Z
END

ALLEEN NATUURLIJKE GETALLEN GRAAG.
De computer kan zeer snel rekenen, maar kan dit extra snel als er alleen
gehele getallen worden gebruikt. Ze nemen namelijk minder geheugenruimte
in beslag. Deze getallen worden INTEGERS genoemd. Je kunt van ieder getal
een integer maken door % aan het eind van de variabele te plaatsen. De waarde
van een integer ligt tussen -32768 en +32768.
Voorbeeld: A% = 3.9 A% krijgt de waarde 4
B% = SQR(5) 5 = 2.236.. , maar B% krijgt de waarde 2

Vaak is het lastig als je iedere keer % moet toevoegen. Je kunt ook aan het
begin van je programma aangeven welke variabelen integer moeten zijn met
DEFINT (DEFine INTeger).
Voorbeeld: DEFINT A-M. Alle variabelen die met de letters A t/m M beginnen
zijn nu automatisch een integer. Dus Eerste is een integer en Tweede niet.
Er bestaan ook LONG INTEGERS. Die definieer je met DEFLNG en hebben een bereik
van (2
31
) tot 2
31
.

WE RONDEN DE BOEL AF.
Er zijn ook commando's om getallen af te ronden tot integers. Hiermee wordt
geoefend in de onderstaande programma's.

4.3 Het gebruik van integers en het afronden van getallen 4.3 Het gebruik van integers en het afronden van getallen 4.3 Het gebruik van integers en het afronden van getallen 4.3 Het gebruik van integers en het afronden van getallen
CLS
DEFINT A-Z 'ALLE variabelen zijn nu integers
G1 = 2.345: G2 = 4.556: P = G1 * G2
PRINT "G1 = "; G1, "G2 = "; G2, "G1 * G2 = "; P
PRINT
PRINT INT(5.9) 'INT rondt af tot een kleiner integer
PRINT INT(-5.9)
PRINT FIX(5.9) 'FIX laat de decimalen weg
PRINT FIX(-5.9)
PRINT CINT(5.49) 'CINT rondt af tot een geheel getal
PRINT CINT(5.50)
END

4.4 Het bepalen van het decimale gedeelte van een getal 4.4 Het bepalen van het decimale gedeelte van een getal 4.4 Het bepalen van het decimale gedeelte van een getal 4.4 Het bepalen van het decimale gedeelte van een getal
CLS
X = 4 * ATN (1) 'manier om pi te berekenen (3.14159265359); ATN = arctan
Y = INT(X) 'Y heeft nu de waarde 3
Z = X - Y 'Z heeft nu de waarde pi - 3 (= 0.14159...)
PRINT X, Y, Z 'alles op het scherm zetten
END

10

4.5 De integerdeling en he 4.5 De integerdeling en he 4.5 De integerdeling en he 4.5 De integerdeling en het bepalen van de rest na een integerdeling t bepalen van de rest na een integerdeling t bepalen van de rest na een integerdeling t bepalen van de rest na een integerdeling
CLS
PRINT "25.68/6.99 = "; 25.68 / 6.99 'uitkomst: 3.6738
PRINT "25.68\6.99 = "; 25.68 \ 6.99 'uitkomst: 3
Rest = 25.68 MOD 6.99 'er wordt berekend: 26\7 = 3
PRINT Rest 'met als rest 5 (3*7=21 + 5 = 26)
END 'of ook: 26/7 = 3 rest 5

WAT EEN TOEVAL!
Het is mogelijk een variabele een willekeurige waarde (tussen 0 en 1) te
geven met het commando RND (RaNDom). De computer bezit als het ware een
voorraad willekeurige getallen (toevalsgetallen). Je kunt deze voorraad
door elkaar schudden met RANDOMIZE TIMER zodat de PC iedere keer begint met
een ander toevalsgetal. RND is vooral handig in spelletjes. Als je een
dobbelsteen wilt nabootsen op de PC gaat dit als volgt;

4.6 Gooien met een dobbelsteen nabootsen 4.6 Gooien met een dobbelsteen nabootsen 4.6 Gooien met een dobbelsteen nabootsen 4.6 Gooien met een dobbelsteen nabootsen
CLS
RANDOMIZE TIMER
FOR i = 1 TO 480 'herhaal de lus 480 keer (hele scherm vol)
A = INT(RND * 6) + 1 'A is minimaal 1 en maximaal 6
PRINT A; " "; 'waarden gescheiden door een spatie
NEXT i 'i wordt 1 groter en terug naar FOR
END

In dit programma komt een lus voor die begint met FOR en eindigt met NEXT.
Deze lus wordt besproken in hoofdstuk 12. In het kort komt het hier op neer
dat alle opdrachten die tussen FOR en NEXT staan herhaald worden uitgevoerd.
In dit voorbeeld zelfs 480 keer!

Opdracht bij programma 4.6
Verander de printopdracht in: PRINT USING "##"; A;
Start opnieuw. Zie je dat het scherm op een andere manier wordt vol-
geschreven?
Snap je wat de toevoeging USING en "##" voor effect heeft? Zo niet,
verander dan "##" in "#" of in "###" of zelfs in "####" en start opnieuw.
Let goed op hoe het scherm met getallen gevuld wordt.

De opdracht PRINT USING wordt later uitgebreider toegelicht.

11

H HH HOO OO OO OOFDST FDST FDST FDSTU UU UK 5 K 5 K 5 K 5 VARIABELEN (2): STRINGVARIABELEN VARIABELEN (2): STRINGVARIABELEN VARIABELEN (2): STRINGVARIABELEN VARIABELEN (2): STRINGVARIABELEN

STRINGVARIABELEN
Het gaat hier om letters of tekst. Iedere stringvariabele eindigt met $ (van
string). Voorbeeld: Hallo$ = "Goede morgen!": PRINT Hallo$ (spreek uit:
hallo-string). Dit voorbeeld heeft als resultaat dat op het scherm komt te
staan: Goede morgen!

Bij de toekenning moeten "" gebruikt worden. Dus A$ = B of A$ = 23 is niet
toegestaan.
Je kunt twee (of meer) stringvariabelen (kortweg: strings) bij elkaar optellen
en daarmee een nieuwe stringvariabele maken: A$ = "Goede": B$ = " morgen":
C$ = A$ + B$. Wat is C$ dus?

Hieronder volgt een oefening waarin je straks wat verbeteringen moet aan-
brengen.

5.1 Oefenen met stringvariabelen 5.1 Oefenen met stringvariabelen 5.1 Oefenen met stringvariabelen 5.1 Oefenen met stringvariabelen
CLS
Voornaam$ = "Lodewijk Friso Mathijs Krelis"
Achternaam$ = "van Appelflap tot Roomsoes"
Naam$ = Voornaam$ + Achternaam$
PRINT Naam$
PRINT
Eind$ = "Eindcijfer"
Eind = (5 + 7 + 8 + 9) / 4
PRINT Eind$; Eind
END

Opdrachten bij programma 5.1
Je ziet dat "Krelis" en "van" aan elkaar worden geschreven. Hoe kun je dit
verhelpen ZONDER Voornaam$ en/of Achternaam$ te veranderen?
Hoe moet je het tweede gedeelte van het programma wijzigen zodat er op het
scherm komt te staan: Eindcijfer = 7.25 (je mag Eind$ NIET veranderen)?

ASCII-KARAKTERS, WAT ZIJN DAT PRECIES?
Totaal zijn er 256 karakters die variren van gewone letters via bijzondere
letters (zoals , , , , ) tot speciale tekens (zoals , , , ). Ieder
karakter heeft een bepaalde waarde: de ASCII-waarde (= American Standard Code
for Information Interchange). Een overzicht van alle ASCII-karakters met hun
waarden kun je opvragen met <Shift><F1>, <Enter> en kies dan voor ASCII
Character Codes.
Je kunt n zo'n karakter in een programma op het scherm laten zetten met PRINT
CHR$(). Op de stippeltjes vul je een getal tussen 0 en 255 in.

LET OP: Niet ieder karakter kan getoond worden. Sommige karakters hebben
namelijk een speciale functie zoals een geluidssignaal, een carriage return
en dergelijke. Met een truc kun je de bijbehorende tekens wl op het scherm
krijgen, maar dat is voor gevorderden.

Ook in je programmatekst kun je bijzondere letters of tekens gebruiken. Typ
hiervoor in <Alt> gevolgd door ASCII-waarde (invoeren met numerieke toetsen-
bord). Probeer maar eens <Alt>130 (), <Alt>137 (), <Alt>253 (), etc.

Soms heb je van een bepaald karakter de bijbehorende ASCII-waarde nodig.
Hiervoor gebruik je het commando ASC(). Zie programma 5.2.

12

5.2 Oefenen met CHR$( ) en ASC() 5.2 Oefenen met CHR$( ) en ASC() 5.2 Oefenen met CHR$( ) en ASC() 5.2 Oefenen met CHR$( ) en ASC()
CLS
PRINT CHR$(65); CHR$(66); CHR$(67)
PRINT CHR$(0); CHR$(255)
PRINT CHR$(7); CHR$(13)
PRINT TAB(20); CHR$(201); CHR$(205); CHR$(187)
PRINT : PRINT
GrA = ASC("A"): KlA = ASC("a")
PRINT GrA, KlA
X = ASC("APPEL"): Y = ASC("anders")
PRINT X, Y
PRINT ASC(CHR$(100)), ASC(CHR$(50))
PRINT CHR$(ASC(CHR$(100)) + ASC(CHR$(50))), CHR$(150)
END

Na het starten hoorde je een geluidssignaal. Dit kwam door het printen van
CHR$(7). Zoals hierboven al verteld werd, kun je niet alle karakters op het
scherm krijgen. CHR$(7) is daar n van. Hetzelfde geldt hier voor de waarde
13. Na PRINT CHR$(13) krijg je een carriage return (de cursor springt naar
de volgende regel zonder iets te printen).

Zoek uit wat er aan het eind van het programma gebeurt.
Wijzig een paar van de ASCII-waarden en start opnieuw. Resultaat?

KUN JE GETALLEN EN STRINGS COMBINEREN?
Dat kan. Soms is het handig om getallen om te zetten in strings. Bijvoorbeeld
wanneer je de lengte van een bepaald getal wilt weten. Dit omzetten kan met
STR$(). Stel X = 12345 dan heeft X$ = STR$(X) tot gevolg dat X$ = "12345".
Je kunt nu stringopdrachten uitvoeren met X$ (zie volgende bladzijde).
Het omzetten van een string naar een getal gebeurt met VAL(): X = VAL(X$).
X heeft nu de waarde 12345.
Overigens is de lengte van een string maximaal 255 karakters. De lengte kan
bepaald worden met LEN(). Voorbeeld: X = LEN(X$). Nu heeft X de waarde 5 want
"12345" is een string van 5 karakters.

5.3 Oefenen met STR$(), VAL() en LEN() 5.3 Oefenen met STR$(), VAL() en LEN() 5.3 Oefenen met STR$(), VAL() en LEN() 5.3 Oefenen met STR$(), VAL() en LEN()
CLS
A$ = "123": B$ = "456"
PRINT A$, B$, A$ + B$, B$ + A$
PRINT LEN(A$) + LEN(B$), LEN(A$ + B$)
PRINT VAL(A$), VAL(B$)
PRINT VAL(A$ + B$), VAL(A$) + VAL(B$)
PRINT VAL(B$ + A$), VAL(B$) + VAL(A$)
PRINT 3 * VAL(A$), VAL(B$) MOD 5
C$ = STR$(VAL(A$ + B$))
PRINT C$
D$ = STR$(9034)
PRINT D$
PRINT VAL(CHR$(67)), VAL(CHR$(65) + "A")
PRINT VAL(" -3"), VAL("HALLO")
END

13

Loop het programma stap voor stap na en kijk goed op het scherm wat het
resultaat is. Kun je alles verklaren?

WAT KUN JE NOG MEER DOEN MET STRINGS?
Er zijn behoorlijk veel stringopdrachten. Hieronder worden de belangrijkste
genoemd met hun betekenis en een voorbeeld. Zorg dat je ze kent. Straks volgen
oefeningen.

LCASE$() Maakt kleine letters. LCASE$("HALLO")

"hallo
UCASE$() Maakt hoofdletters. LCASE$("Hallo")

"HALLO"
LTRIM$() Verwijdert spaties links. LTRIM$(" hoi")

"hoi"
RTRIM$() Verwijdert spaties rechts. RTRIM$("hoi ")

"hoi"
SPACE$() Geeft string met spaties. SPACE$(5)

" "
STRING$() Geeft string van bepaalde
lengte met karakter. of
STRING$(4, "G")
STRING$(4, 71)

"GGGG"
"GGGG"
LEFT$() Geeft linker gedeelte van
string met bepaalde lengte
LEFT$("Hallo", 3)

"Hal"
RIGHT$() Geeft rechter gedeelte van
string met bepaalde lengte.
RIGHT$("Hallo", 3)

"llo"
MID$() Geef midden gedeelte van
string met bepaalde lengte
vanaf een bepaald beginpunt.
MID$("Hallo", 2, 3)

"all"
INSTR() Zoekt een string in een andere
string vanaf bepaald beginpunt.
INSTR(i,"bestand.ext",".") = 8

Toelichting bij STRING$(): Uit het voorbeeld blijkt dat je in plaats van het
karakter ook de ASCII-waarde mag geven (71 is de ASCII-waarde voor G).Dit is
vooral handig als je met STRING$() karakters wilt weergeven die niet op het
toetsenbord staan (o.a. alle karakters van waarden boven 126).

Toelichting bij INSTR(): Er wordt gezocht in "bestand.ext" vanaf de eerste
positie (mag je weglaten). De punt wordt op de 8
e
positie gevonden. Er wordt
altijd van links naar rechts gezocht.
Als in de opdracht X = INSTR(zin$, ".") gn punt gevonden kan worden in zin$,
krijgt X de waarde 0.

5.4 Oefenen met stringopdrachten 5.4 Oefenen met stringopdrachten 5.4 Oefenen met stringopdrachten 5.4 Oefenen met stringopdrachten
CLS
A$ = " ABCDEFGHIJKLMNOPQRSTUVWXYZ "
B$ = " zyxwvutsrqponmlkjihgfedcba "
PRINT LEN(A$), LEN(B$)
PRINT LCASE$(A$), UCASE$(B$)
C$ = LTRIM$(RTRIM$(A$)) + RTRIM$(LTRIM$(B$))
PRINT LEN(C$); " "; C$; " "; MID$(C$, 20, 10)
X = INSTR(C$, "f")
PRINT "f gevonden op plaats"; X; "in C$."
Y = INSTR(C$, "KLM")
PRINT "KLM gevonden op plaats"; Y; "in C$."
PRINT
PRINT STRING$(5, 127)
END

14

HOOFDSTUK 6 HOOFDSTUK 6 HOOFDSTUK 6 HOOFDSTUK 6 VARIABELEN (3): ARRAYVARIABELEN VARIABELEN (3): ARRAYVARIABELEN VARIABELEN (3): ARRAYVARIABELEN VARIABELEN (3): ARRAYVARIABELEN

ARRAYVARIABELEN
Vaak is het handig als je een variabelenaam kunt gebruiken voor meerdere
variabelen. Als je in een programma bijvoorbeeld tien proefwerkcijfers nodig
hebt is, het onhandig als je namen moet gebruiken als EersteCijfer,
TweedeCijfer, DerdeCijfer etc. (of zelfs C1, C2, C3). Een oplossing hiervoor
biedt de array (= reeks). Hierbij krijgt iedere variabele met dezelfde naam
een bepaald nummer (we spreken dan van element). Dit nummer (of index) staat
tussen haakjes. Bijvoorbeeld: C(1), C(2), C(3) zijn drie elementen van de
array C. Het voordeel ten opzichte van C1, C2, C3 etc. is, dat je de elementen
ook met andere variabelen kunt aanduiden. Hierover een oefening.

6.1. Oefenen met array's (1) 6.1. Oefenen met array's (1) 6.1. Oefenen met array's (1) 6.1. Oefenen met array's (1)
CLS
C(1) = 4.5: C(2) = 6.7: C(3) = 5.9: C(4) = 6.0: C(5) = 7.8
Som = C(1) + C(2) + C(3) + C(4) + C(5)
Gem = Som / 5
PRINT "Gemiddelde:"; Gem
I = 2
PRINT C(I)
J = 2 * I - 1
PRINT "Inhoud"; J; "e element:"; C(J)
END

Opmerkingen bij programma 6.1
Vooral bij het werken met lussen (zie hoofdstuk 12) zijn arrays erg handig.
Het laagste element is C(0). Hier geldt: C(0) = 0.

EFFE DIMME
Voor de arrays moet de PC geheugenruimte reserveren. Je moet daarom van te
voren aangeven hoeveel elementen je nodig denkt te hebben. Dit heet
dimensioneren en gebeurt met het commando DIM. Hiermee kun je alle arrays
dimensioneren. Een array bevat of getallen of strings, maar nooit beide
tegelijk. Een stringarray geef je aan met de toevoeging $. De array Tekst$()
is dus een stringarray.

6.2. Oefenen met array's (2) 6.2. Oefenen met array's (2) 6.2. Oefenen met array's (2) 6.2. Oefenen met array's (2)
LET OP: er zullen foutmeldingen optreden bij het starten. Probeer te begrijpen waarom
de foutmelding optreedt. Vraag het programma desnoods om hulp. Verwijder de verkeerde
regel of plaats er een ' voor (dan wordt het een REMark) en start opnieuw.
CLS
DIM Naam$(3), Leeftijd(3)
Naam$(0) = "Jan": Naam$(1) = "Carla"
Naam$(2) = "Peter": Naam$(3) = "Anna"
Leeftijd(0) = 14: Leeftijd(1) = 16
Leeftijd(2) = 17: Leeftijd(3) = 15
FOR I = 0 TO 3
PRINT Naam$(I); " is"; Leeftijd(I); "jaar oud."
NEXT I
PRINT Naam$(-1)
PRINT Leeftijd(4)
END

15

In dit programma komt een lus voor, net als in programma 4.6. Geen nood als
je niet begrijpt wat er precies gebeurt. In hoofdstuk 12 en 13 komen de lussen
aan de orde.
Bij het dimensioneren moet je van te voren een beetje inschatten hoeveel
elementen je nodig hebt. Hoewel niet fout, is het toch wat overdreven om
bijvoorbeeld 10000 elementen te reserveren als je er maar 10 gebruikt.

IS DAT ALLES WAT JE MET ARRAYS KUNT DOEN?
Nee! Er is nog veel meer mogelijk. Een paar voorbeelden (hierbij horen geen
programmas):
1. De indices hoeven niet te lopen van 0 tot ... Als je in een array de
jaarsalarissen over de jaren 2007 t/m 2013 wilt opslaan, kun je deze als
volgt dimensioneren: DIM JrSal(7 TO 13). De elementen komen nu handig
overeen met de jaartallen. Sterker nog: je kunt zelfs negatieve getallen
gebruiken, maar het moeten wel allemaal gehele getallen zijn!
2. Als je liever als laagste element de index 1 gebruikt (in plaats van 0)
kun je dit aangeven met de opdracht OPTION BASE 1.
3. Een array kan ook meerdere dimensies hebben (maximaal 63). In een twee
dimensionale array zou je bijvoorbeeld ook de maandsalarissen kunnen
opslaan: DIM Salaris(7 TO 13, 1 TO 12). Het maandsalaris van april 2010
staat dan in element Salaris(10, 4).

16

HOOFDSTUK 7 HOOFDSTUK 7 HOOFDSTUK 7 HOOFDSTUK 7 GEGEVENS INVOEREN (1) GEGEVENS INVOEREN (1) GEGEVENS INVOEREN (1) GEGEVENS INVOEREN (1)

WAT MAG HET ZIJN?
In alle bovenstaande programmas werden de waarden van variabelen in het
programma vastgelegd. In de praktijk zal het vaak voorkomen dat er gegevens
ingevoerd moeten worden. Meestal vanaf het toetsenbord, maar er kunnen ook
gegevens van een schijf gelezen worden. Het gaat hier om de invoer vanaf het
toetsenbord.
Typ het onderstaande programma in en voer dan de opdrachten uit.

7.1 Oefenen met invoeren vanaf het toetsenbord (1) 7.1 Oefenen met invoeren vanaf het toetsenbord (1) 7.1 Oefenen met invoeren vanaf het toetsenbord (1) 7.1 Oefenen met invoeren vanaf het toetsenbord (1)
CLS
INPUT A
PRINT "Je hebt"; A; "ingevoerd."
INPUT "Voer een getal in: "; Getal
INPUT "Getal = ", Getal
INPUT "Voer een korte zin in: ", Zin$
PRINT "Heb je ingevoerd: '"; Zin$; "'?"
LINE INPUT "Voer de zin nogmaals in: ", Zin$
PRINT "Klopt het nu wel: "; Zin$
END

Start het programma met <Shift>F5.
Voer een letter of een woord in (en druk op <Enter>).
Dit mocht dus kennelijk niet. Voer nu een getal in.
Voer een getal in en, na <Enter>, daarna weer n. Let op de aan- en
afwezigheid van het vraagteken en onderzoek hoe dit in het programma
verwerkt is.
Bij: "Voer een korte zin in:" moet je iets invoeren met leestekens,
bijvoorbeeld: hallo, ik ben ....
Je mag dus bij INPUT geen leestekens gebruiken. Voer nu de zin in zonder
leestekens.
Als gevraagd wordt nogmaals de zin in te voeren, kun je wel leestekens
gebruiken. Kijk in het programna waarom het nu wel kan.

Typ het onderstaande programma in en probeer de gegevens in te voeren zonder
dat er "Redo from Start" verschijnt.

7.2. Oefenen met invoeren vanaf het toetsenbord (2) 7.2. Oefenen met invoeren vanaf het toetsenbord (2) 7.2. Oefenen met invoeren vanaf het toetsenbord (2) 7.2. Oefenen met invoeren vanaf het toetsenbord (2)
CLS
INPUT A, B, C 'geef bij voorkeur aan wat
INPUT A$, B$, C$ 'er ingevoerd moet worden
LOCATE 12, 20 'nu moet je raden: getal, woord?
INPUT " "; Naam$, Leeftijd 'of beide? en hoe vaak?
LOCATE 5, 1 'kortom: wees duidelijk
PRINT "Voer de code 1993 in: ";
X$ = INPUT$(4)
PRINT "Je hebt "; X$; " ingevoerd."
END

Vraag: wat is het verschil tussen INPUT, LINE INPUT en INPUT$()?

17

HOODSTUK 8 HOODSTUK 8 HOODSTUK 8 HOODSTUK 8 ZELF PROGRAMMA ZELF PROGRAMMA ZELF PROGRAMMA ZELF PROGRAMMAS S S S MAKEN (1) MAKEN (1) MAKEN (1) MAKEN (1)

Hieronder staan wat opdrachten, waarbij je alles wat je in de voorgaande
hoofdstukken hebt geleerd kunt toepassen. Het is de bedoeling dat je korte
programma's maakt. Gebruik, als je problemen krijgt, zoveel mogelijk de
Helpfunctie van QuickBASIC. Als je de programma's wilt bewaren, kies je uit
het File-menu de optie Save. Je geeft het programma een naam van maximaal 8
letters en dan wordt het naar de schijf geschreven.

1 Maak een programma dat de volgende berekeningen uitvoert en de uitkomsten
op het scherm toont: a. 2 x 4 + 6 b. 5 + 8 : 2 c. 20 : 5 x (2 + 7)
De volledige berekening moet op het scherm komen. Dus bij a. moet op het
scherm komen: 2 x 4 + 6 = 14.

2 Voeg in het programma van opdracht 1 na a de berekening 16 + 24 : 4 toe.

3 Maak een programma dat op het scherm het volgende resultaat geeft:
De uitkomst van 2 - 12 is: -10
De uitkomst van 1/4 is: .25

4 Maak een programma dat om 5 getallen vraagt; ze onder elkaar afdrukt en
daar onder het gemiddelde vermeldt.

5 Maak een programma dat om 2 getallen vraagt (x en y) en vervolgens op
het scherm de antwoorden van de volgende berekeningen toont: x + y; x
- y; x * y en x / y. Toon de gehele berekening op het scherm. Wat gebeurt
er als je voor y de waarde 0 invoert?

6 Maak een programma dat vraagt naar je naam, adres, woonplaats etc. en
dit vervolgens op fraaie wijze op het scherm tovert (gebruik o.a. LOCATE).

7 Maak een programma waarbij 5 woorden moeten worden ingevoerd. Daarna
moeten die woorden, met ernaast de bijbehorende lengtes (LEN$), op het
scherm worden afgedrukt.

8 Maak een programma dat om 5 getallen tussen 32 en 254 vraagt en vervolgens
de getallen met het bijbehorende ASCII-karakters toont.
Bijv. 65 A.
Laat het programma daarna om 5 karakters vragen en toon ze met de waarden
op het scherm. Bijvoorbeeld $ 36.

9 Maak een programma waarbij je een zin invoert (gebruik LINE INPUT), waarin
"huis" voorkomt (dus huiswerk is ook goed). Vind de plaats waar "huis"
begint in de zin (met INSTR). Toon de zin op het scherm waarbij je "huis"
laat weergeven in zwarte letters op een witte achtergrond (gebruik o.a.
LOCATE en COLOR).

10 Maak een programma dat willekeurig een ASCII-waarde boven 32 berekent
en dit als een string met een lengte van 400 op het scherm toont (gebruik
onder andere STRING$ en RND).

18

HOOFDSTUK HOOFDSTUK HOOFDSTUK HOOFDSTUK 9 99 9 BESLISSINGSSTRUCTUREN (1): IF...THEN...ELSE BESLISSINGSSTRUCTUREN (1): IF...THEN...ELSE BESLISSINGSSTRUCTUREN (1): IF...THEN...ELSE BESLISSINGSSTRUCTUREN (1): IF...THEN...ELSE

NEEM EENS EEN BESLUITJE
Een bekend spelletje is dat iemand een getal moet raden en als aanwijzing
alleen maar krijgt dat zijn gekozen getal te hoog of te laag is. Als een
computer die aanwijzingen moet geven, dan moet de PC de volgende opdracht
kunnen uitvoeren (te raden getal is X): "als getal kleiner is dan X, moet ik
vermelden 'te laag'; als getal groter is dan X, moet ik vermelden 'te hoog';
als getal juist is, moet ik vermelden 'geraden'". De PC moet dus een beslissing
nemen. Dit kan met de commandostructuur IF...THEN...ELSE.
De begrippen 'groter dan', 'kleiner dan' etc. komen uit de wiskunde. Hier volgt
een overzicht van wat de PC kent:

kleiner dan: < groter dan: >
kleiner of gelijk: <= groter of gelijk: >=
gelijk aan: = ongelijk aan: <>

Voorbeeld
Stel in een programma komen de volgende regels voor:
INPUT "Getal: ", G
IF G > 100 THEN PRINT "G > 100"
PRINT "Einde programma"

Eerst moet je een getal G invoeren. In de volgende regel controleert de PC
of dit getal groter is dan 100. Zo ja, dan wordt geprint "G > 100", zo niet
dan wordt direct naar de volgende regel gesprongen. Kortom: alle opdrachten
na THEN worden alleen uitgevoerd als aan de voorwaarde voldaan is. Anders
gezegd: als de ongelijkheid juist is.

9.1 Eenvoudig gebruik van IF...THEN...ELSE; kop of munt nabootsen 9.1 Eenvoudig gebruik van IF...THEN...ELSE; kop of munt nabootsen 9.1 Eenvoudig gebruik van IF...THEN...ELSE; kop of munt nabootsen 9.1 Eenvoudig gebruik van IF...THEN...ELSE; kop of munt nabootsen
CLS
RANDOMIZE TIMER 'zie hoofdstuk 4
X = RND 'X is willekeurig getal tussen 0 en 1
IF X <= .5 THEN PRINT "kop" 'kop en munt nabootsen met willekeurige
IF X > .5 THEN PRINT "munt" 'getallen
REM Andere manier:
Y = RND 'Y is willekeurig getal tussen 0 en 1
IF Y <= .5 THEN PRINT "kop" ELSE PRINT "munt"
REM Nog een andere manier (met een 'blok'):
Z = RND 'Z is willekeurig getal tussen 0 en 1
IF Z <= .5 THEN 'een 'blok' gebruiken is de meest
PRINT "kop" 'overzichtelijke manier (zie verder)
ELSE
PRINT "munt"
END IF 'een 'blok' ALTIJD eindigen met END IF
END

Opmerking bij programma 9.1
Je ziet dat het gebroken getal 0,5 wordt aangegeven met .5. Natuurlijk mag
0.5 ook, maar je mag dus GEEN komma gebruiken.
In een blok kun je ook meerdere commandos plaatsen. Het inspringen is niet
noodzakelijk, maar maakt het geheel wat overzichtelijker.
Het is toegestaan om ELSE weg te laten (zie eerste gedeelte) als dit voor de
beslissing niet nodig is.

19

9.2 Nogmaals IF...THEN...ELSE; het getalprogramma (e 9.2 Nogmaals IF...THEN...ELSE; het getalprogramma (e 9.2 Nogmaals IF...THEN...ELSE; het getalprogramma (e 9.2 Nogmaals IF...THEN...ELSE; het getalprogramma (eenvoudige versie). envoudige versie). envoudige versie). envoudige versie).
Opmerking: in dit programma wordt de lus DO...LOOP gebruikt. Deze lus wordt
nader toegelicht in hoofdstuk 13.
CLS
PRINT "Raad een geheel getal tussen 1 en 1000. ";
PRINT "Stoppen door 0 in te voeren."
PRINT
RANDOMIZE TIMER
Getal = INT(RND * 1000) + 1 'willekeurig geheel getal tussen 1 en 1000
DO 'begin van de lus DO...LOOP
INPUT "Invoer: ", X 'getal invoeren
IF X = 0 THEN END 'stoppen als 0 is ingevoerd
IF X = Getal THEN 'begin IF...THEN-blok; getal geraden
SOUND 1200, 5 'overwinningsgeluid
LOCATE CSRLIN - 1, 15 'CSRLIN = laatst gebruikte regel
PRINT "GERADEN!" 'printen achter juiste getal
END 'einde programma
END IF 'einde IF...THEN-blok
REM Als X <> Getal, wordt bovenstaand blok overgeslagen!
LOCATE CSRLIN - 1, 15
IF X < Getal THEN
PRINT "TE LAAG!" 'wordt nu op zelfde regel getoond als
ELSE 'ingevoerde getal door CSRLIN - 1
PRINT "TE HOOG!"
END IF
LOOP 'terug naar DO

In dit programma wordt TE LAAG! en TE HOOG! op dezelfde regel geprint als het
ingevoerde getal. Na invoer verspringt de cursor vanzelf naar de volgende
regel. De positie van de cursor wordt automatisch opgeslagen in CSRLIN
(CuRSorLINe de regel waarop de cursor staat; regelnummer) en in POS(0)
(POSition de kolom waarin de cursor staat; kolomnummer).
Dit gegeven wordt hier gebruikt om de tekst n regel hoger te printen,
namelijk op regel CSRLIN 1.

IS JOOP GROTER DAN PETER EN JOLANDA?
Je kunt niet alleen getallen, maar ook strings met elkaar vergelijken. In feite
worden dan de ASCII-waarden (zie Hoofdstuk 5) van de karakters met elkaar
vergeleken. Stel dat A$ = "Joop" en B$ = "Annet", dan geldt A$ > B$, want de
ASCII-waarde van "J" (74) is groter dan de ASCII-waarde van "A" (65). Maar
ook als A$ = "Joop" en B$ = "Jolanda" geldt A$ > B$, want het verschil
tussen beide strings treedt nu op bij de derde letter en "o" > "l".

Hieronder een programma waarin strings met elkaar worden vergeleken. Het gaat
hierbij slechts om n karakter, dat direct vanaf het toetsenbord wordt
ingelezen (dus zonder <Enter>). In hoofdstuk 7 heb je geleerd dat dit kan met
behulp van INPUT$().

20

9.3 9.3 9.3 9.3. Het gebruik van strings in IF...THEN...ELSE . Het gebruik van strings in IF...THEN...ELSE . Het gebruik van strings in IF...THEN...ELSE . Het gebruik van strings in IF...THEN...ELSE
CLS
PRINT "Voer het karakter @ in. ";
kar$ = INPUT$(1)
IF kar$ <> "@" THEN
PRINT "Je hebt GEEN @ ingevoerd!"
ELSE
PRINT "Goed zo!"
END IF
PRINT : SLEEP 2
PRINT "Vind je dit een leuke cursus? (J/N of j/n) "
kar$ = UCASE$(INPUT$(1))
IF kar$ = "J" THEN PRINT "Wat aardig van je."
IF kar$ = "N" THEN PRINT "Wat jammer nou."
IF kar$ <> "J" AND kar$ <> "N" THEN PRINT "Verkeerde invoer!"
END

Het gebruik van INPUT$() heeft een nadeel. Als je in plaats van @ op <Esc>
had moeten drukken, dan had INPUT$() deze invoer niet geaccepteerd. Toch komt
het drukken op <Esc> (of op <Enter>) vaak voor. Bijvoorbeeld om een programma
te beindigen. Het probleem kan worden verholpen met het commando INKEY$. Dit
komt ter sprake in hoofdstuk 11.

Onthoud vooral de truc om de invoer van zowel kleine letters als hoofdletters
te accepteren (gebruik van UCASE$).

In het tweede gedeelte moet de PC drie dingen nagaan: 1. J ingevoerd?, 2. N
ingevoerd? of 3. Geen van beide ingevoerd? Hiervoor wordt drie keer IF...THEN
gebruikt. Stel dat je de letters A t/m Z kunt invoeren en iedere invoer heeft
een bepaalde betekenis, dan zou je dus 26 keer IF...THEN moeten gebruiken.
Dit is bijzonder omslachtig. Om die reden is het commando SELECT CASE bedacht.
In het volgende hoofdstuk zie je de voordelen van dit commando.

Tenslotte zie je bij de laatste IF...THEN dat er AND is gebruikt. Aan beide
voorwaarden moet worden voldaan. Je kunt ook OR gebruiken. Dan hoeft slechts
aan n van de voorwaarden te worden voldaan. Over het gebruik van AND en OR
volgt hieronder nog een programma.

9.4 Het gebruik van AND en OR in IF...THEN...ELSE 9.4 Het gebruik van AND en OR in IF...THEN...ELSE 9.4 Het gebruik van AND en OR in IF...THEN...ELSE 9.4 Het gebruik van AND en OR in IF...THEN...ELSE
CLS
INPUT "Voer een getal in tussen 0 en 10: ", x
IF x > 0 AND x < 10 THEN
PRINT "Het getal was:"; x
ELSE
PRINT x; "ligt niet tussen 0 en 10!"
END IF
PRINT
INPUT "Voer een x of een X in. ", x$
IF x$ = "x" OR x$ = "X" THEN
PRINT "Goed zo!"
ELSE
PRINT "Dit is geen x of X!"
END IF
END

21

HOOFDSTUK 10 HOOFDSTUK 10 HOOFDSTUK 10 HOOFDSTUK 10 BESLISSINGSSTRUCTUREN (2): SELECT CASE BESLISSINGSSTRUCTUREN (2): SELECT CASE BESLISSINGSSTRUCTUREN (2): SELECT CASE BESLISSINGSSTRUCTUREN (2): SELECT CASE
KIES HET GEVAL MAAR UIT.
SELECT CASE is bijzonder handig als je verschillende mogelijkheden moet
nagaan. Met SELECT CASE kun je ze allemaal langslopen. Eerst een eenvoudig
voorbeeld, uiteraard in de vorm van een programma.

10.1 Bepalen of een hoofdletter of een kleine letter is ingevoerd 10.1 Bepalen of een hoofdletter of een kleine letter is ingevoerd 10.1 Bepalen of een hoofdletter of een kleine letter is ingevoerd 10.1 Bepalen of een hoofdletter of een kleine letter is ingevoerd
CLS
PRINT "Voer een letter in. "
L$ = INPUT$(1)
SELECT CASE L$
CASE "A" TO "Z"
PRINT "Je hebt de hoofdletter "; L$; " ingevoerd!"
CASE "a" TO "z"
PRINT "Je hebt de kleine letter "; L$; " ingevoerd!"
CASE ELSE
PRINT "Je hebt iets verkeerds ingevoerd, namelijk: "; L$
END SELECT
END

Wat opvalt, is dat je met "A" TO "Z" een gebied kunt aangeven. Natuurlijk kan
dit ook met getallen, bijvoorbeeld CASE 1 TO 10.
Zeer handig is ook CASE ElSE. Hiermee heb je alle overige gevallen te pakken.
In dit geval als je bijvoorbeeld een cijfer of een leesteken invoert.
Denk er aan dat je altijd eindigt met END SELECT.

Maak een programma dat hetzelfde kan als 10.1, maar nu moet je gebruik maken
van IF...THEN...ELSE. Let dan vooral op het verschil tussen beide programma's.

Bij spelletjes kun je vaak dingen bewegen met behulp van de cursortoetsen.
Deze bijzondere toetsen (ook <Home>, <End> etc.) worden ook gebruiken in
programmas van deze cursus. Dit wordt nader toegelicht in hoofdstuk 11. Ook
hier zal gebruik worden gemaakt van het commando SELECT CASE.

Hieronder nog een voorbeeld, waarbij tevens het commando PRINT USING wordt
uitgelegd (zie ook het eerste programma op bladzijde 3).

22

10.2. Het gebruik van PRINT USING en nogmaals SELECT CASE 10.2. Het gebruik van PRINT USING en nogmaals SELECT CASE 10.2. Het gebruik van PRINT USING en nogmaals SELECT CASE 10.2. Het gebruik van PRINT USING en nogmaals SELECT CASE
CLS
A = 3.14: B = 234.21: C = 94.37
INPUT "Op hoeveel decimalen weergeven (0 tot 2): ", dec
SELECT CASE dec
CASE 0
M$ = "A = ### B = ### C = ###"
CASE 1
M$ = "A = ###.# B = ###.# C = ###.#"
CASE 2
M$ = "A = ###.## B = ###.## C = ###.##"
CASE ELSE
PRINT "Je had 0, 1 of 2 moeten invoeren!"
END
END SELECT
PRINT
PRINT USING M$; A; B; C
PRINT
M$ = "\ \= ###.### \ \= ###.###"
G1$ = "Getal 1": G2$ = "Getal 2"
G1 = 34.5665: G2 = 231.22
PRINT USING M$; G1$; G1; G2$; G2
END

Met PRINT USING kun je de lay out aanpassen. Met de ##-jes bepaal je hoeveel
cijfers er weergegeven moeten worden. Erg handig bij tabellen. Het gebruik
van een string (zoals M$) is natuurlijk niet verplicht. Ook goed is bijvoor-
beeld: PRINT USING "A = ###.###"; A. Ook de lengte van de weer te geven tekst
kan met PRINT USING worden vastgelegd. Hiervoor gebruik je \\-jes.

Verander in de SELECT CASE-opdracht het aantal ##jes en bekijk wat hiervan
het gevolg is als je opnieuw start.
Verwissel de variabelen in de laatste PRINT USING-opdracht en bekijk wat
hiervan het gevolg is. Treden er foutmeldingen op? Waarom?

23

HOODSTUK 11 HOODSTUK 11 HOODSTUK 11 HOODSTUK 11 HET GEBRUIK VAN HET TOETSENBORD IN PROGRAMMA'S HET GEBRUIK VAN HET TOETSENBORD IN PROGRAMMA'S HET GEBRUIK VAN HET TOETSENBORD IN PROGRAMMA'S HET GEBRUIK VAN HET TOETSENBORD IN PROGRAMMA'S

EEN LEESSTUK.
Het nu volgende stuk tekst is bedoeld als inleiding op het gebruik van
bijzondere toetsen in programma's. Bijvoorbeeld de cursortoetsen om iets te
laten bewegen. Je leert in dit hoofdstuk hoe je die toetsen kunt 'activeren'.

WEL OF GEEN TEKST INVOEREN
Je kunt via het toetsenbord zowel tekst intypen als opdrachten geven. Als je
bijvoorbeeld het File-menu activeert, kun je de optie Save kiezen door op de
s te drukken. Er komt dan GEEN s op het scherm te staan, maar er wordt een
opdracht uitgevoerd.

WAT GEBEURT ER PRECIES ALS JE EEN TOETS INDRUKT?
Wanneer je een a intypt, verstuurt het toetsenbord twee speciale codes naar
het brein van de computer (CPU genaamd; van Central Processing Unit). De eerste
code geeft aan DAT er een toets is ingedrukt. De tweede is een zogeheten Scan
Code waarmee aangegeven wordt WELKE toets er is ingedrukt. Voor een a (of A)
is de Scan Code 30. Een Scan Code is voor een hoofdletter en een kleine letter
hetzelfde.

SCAN CODES EN ASCII-WAARDEN.
De Scan Codes hebben helemaal niets te maken met de ASCII-waarden van een
karakter. De Scan Code die wordt doorgegeven wordt omgezet in een
ASCII-waarde. Hierbij maakt het uit of <Shift> wel of niet is ingedrukt. Ook
dit wordt aan de CPU doorgegeven. Als <Shift> niet is ingedrukt zal Scan Code
30 worden omgezet in een ASCII-waarde van 97, behorend bij de letter a. Als
<Shift> wel is ingedrukt wordt Scan Code 30 omgezet in een ASCII-waarde van
65, behorend bij de letter A. Wat er dan gebeurt, hangt helemaal van het
programma af. Als het gaat om het intypen van tekst zal er een a (of A) op
het scherm komen, maar er kan ook een bepaalde opdracht uitgevoerd worden.

EEN TOETSINDRUK REGISTREREN
Er zijn twee opdrachten om een enkele toetsindruk te registreren: INPUT$(1)
en INKEY$. Het verschil tussen beide opdrachten wordt hieronder toegelicht,
waarbij er van uit wordt gegaan dat het resultaat wordt opgeslagen in de string
i$ (maar je mag die string ook een andere naam geven, bijvoorbeeld key$).
i$ = INPUT$(1) Bij deze opdracht wordt er net zo lang gewacht totdat er n
karakter is ingevoerd, aangegeven met (1).
INPU$(1) accepteert geen bijzondere toetsen.
i$ = INKEY$ Als je toetsen indrukt, worden ze tijdelijk opgeslagen in een
buffer. INKEY$ leest het eerste karakter uit die buffer.
INKEY$ wacht dus niet op een toetsindruk. Als je geen toets
indrukt, wordt een string met lengte 0 ingelezen. Daarom wordt
deze opdracht meestal in een lus gezet. Deze lus wordt net
zo lang doorlopen totdat er op een toets is gedrukt. Een
voorbeeld van zon lus is:
DO
i$ = INKEY$
LOOP UNTIL LEN(i$) > 0
De lus DO...LOOP wordt in hoofdstuk 13 nader toegelicht. De
lus wordt net zo lang doorlopen totdat (UNTIL) i$ een lengte
groter dan 0 heeft. Er is dan namelijk een toets ingedrukt.
Met INKEY$ kun je WEL bijzondere toetsen 'registreren'.

24

WAT IS NOU HET VERSCHIL TUSSEN EEN GEWONE EN EEN BIJZONDERE TOETS?
Dit ga je zelf uitzoeken met het onderstaande programma.

11.1 Het verschil tussen een gewone en een bijzondere toets bepalen 11.1 Het verschil tussen een gewone en een bijzondere toets bepalen 11.1 Het verschil tussen een gewone en een bijzondere toets bepalen 11.1 Het verschil tussen een gewone en een bijzondere toets bepalen
CLS
PRINT "Druk steeds op een toets. Stop met <Esc>."
PRINT "Toets: ASCII-waarde:"
DO
DO
i$ = INKEY$
LOOP UNTIL LEN(i$) 'De toevoeging > 0 is niet nodig
PRINT i$, ASC(i$)
LOOP UNTIL i$ = CHR$(27)
END

Dit programma staat ook in hoofdstuk 13, ter illustratie van de lus DO...LOOP.
Stop het programma door op <Esc> te drukken. Bij <Esc> hoort namelijk
ASCII-waarde 27.

Voer een aantal gewone toetsen in: a, r, Y, V (etc).
Voer nu bijzondere toetsen in: cursortoetsen, <Home>, <End> (etc).
Er vallen twee dingen op:
1. Bij de bijzondere toetsen wordt toch een letter op het scherm gezet, maar
deze wordt vooraf gegaan door een spatie.
2. De ASCII-waarde voor alle bijzondere toetsen is 0.

Verklaring:
Een bijzondere toets heeft twee ASCII-waarden, waarvan de eerste altijd de
waarde 0 heeft. Bij CHR$(0) hoort geen bepaald karakter en wordt daarom als
een spatie op het scherm gezet. De tweede ASCII-waarde komt overeen met de
Scan Code van de toets. Als je een bijzondere toets indrukt, heeft i$ dus een
lengte van 2. Bij de opdracht ASC(i$) wordt alleen de ASCII-waarde van
het eerste karakter van i$ getoond, en deze waarde is 0.
Voorbeeld: de ASCII-waarden voor <Home> zijn 0 en 71. Bij een ASCII-waarde
van 71 hoort het karakter "G".

Programma 11.1 wordt nu aangepast, zodat beide ASCII-waarden van een
bijzondere toets zichtbaar zijn.
Verander de PRINTopdracht in: PRINT i$, ASC(i$), ASC(RIGHT$(i$, 1))
Start het programma opnieuw. Snap je de verandering?

DAN NU DE BIJZONDERE TOETSEN ECHT GEBRUIKEN!
De bijzondere toetsen zijn alleen van elkaar te onderscheiden als gekeken
wordt naar de tweede ASCII-waarde. Verwar dit niet met de ASCIIwaarden van
de gewone toetsen. Het drukken op <Home> en op "G" mag dus niet hetzelfde
resultaat opleveren. Er zijn twee manieren om gebruik te maken van die tweede
ASCIIwaarde. Welke manier je kiest is een kwestie van smaak. Beide manieren
worden hieronder toegelicht. Als voorbeeld wordt steeds een bijzondere toets
uitgekozen, namelijk <Home>.

Als op <Home> wordt gedrukt en dit wordt met INKEY$ opgeslagen in i$, dan is
i$ gelijk aan CHR$(0) + CHR$(71), waarbij geldt dat CHR$(71) = "G".

25

Manier 1. Strings voor bijzondere toetsen definiren
Eerst wordt string CN$ gedefinieerd voor CHR$(0): CN$ = CHR$(0).
Vervolgens de string Home$: Home$ = CN$ + "G".
Na de lus met i$ = INKEY$ kan met SELECT CASE bepaald worden of er op <Home>
is gedrukt:
SELECT CASE i$
CASE Home$
(Opdracht)

11.2 Bijzondere toetsen gebruiken (1): strings definiren 11.2 Bijzondere toetsen gebruiken (1): strings definiren 11.2 Bijzondere toetsen gebruiken (1): strings definiren 11.2 Bijzondere toetsen gebruiken (1): strings definiren
CLS
PRINT "Druk op G, <Home> of een andere toets."
CN$ = CHR$(0)
Home$ = CN$ + "G"

DO
i$ = INKEY$
LOOP UNTIL LEN(i$)

SELECT CASE i$
CASE Home$
PRINT "Je hebt op <Home> gedrukt."
CASE "G"
PRINT "Je hebt op G gedrukt."
CASE ELSE
PRINT "Je hebt op een andere toets gedrukt, namelijk ";
IF LEN(i$) > 1 THEN PRINT "een speciale toets." ELSE PRINT i$; "."
END SELECT
END

Manier 2. Maak de tweede ASCII-waarde van bijzondere toetsen negatief
Nadat er op een toets is gedrukt wordt bepaald of de lengte van i$ wel of niet
gelijk aan 1 is. Zo ja, dan is er op een gewone toets gedrukt en verandert
er niets. Zo nee, dan is er op een bijzondere toets gedrukt en wordt de tweede
ASCII-waarde negatief gemaakt. Vervolgens kan met SELECT CASE uitgezocht
worden op welke toets er gedrukt is.

11.3. Bijzondere toetsen gebruiken (2): tweede ASCII 11.3. Bijzondere toetsen gebruiken (2): tweede ASCII 11.3. Bijzondere toetsen gebruiken (2): tweede ASCII 11.3. Bijzondere toetsen gebruiken (2): tweede ASCII- -- -waarde negatief waarde negatief waarde negatief waarde negatief
CLS
PRINT "Voer G, <Home> of een andere toets in."
DO
i$ = INKEY$
LOOP UNTIL LEN(i$)

IF LEN(i$) = 1 THEN
Waarde = ASC(i$)
ELSE
Waarde = -ASC(RIGHT$(i$, 1))
END IF

SELECT CASE Waarde
CASE -71
PRINT "Je hebt op <Home> gedrukt."
CASE 71
PRINT "Je hebt op <G> gedrukt."

26

CASE ELSE
PRINT "Je hebt op een andere toets gedrukt, namelijk ";
IF LEN(i$) > 1 THEN PRINT "een speciale toets." ELSE PRINT i$; "."
END SELECT
END

WAT ZIJN AL DIE TWEEDE ASCII-WAARDEN VAN DE BIJZONDERE TOETSEN?
Hieronder volgt een overzicht. Het gaat hier om functietoetsen en om de toetsen
op het numerieke toetsenbord. Dit toetsenbord wordt gevolgd van links naar
rechts en van boven naar beneden.

Functietoets: 2e ASCII-waarde:

F1 t/m F10 59 t/m 68

Toets op numerieke toetsenbord: 2e ASCII-waarde:

7 / Home 71
8 / 72
9 / PgUp 73
- 74
4 / 75
5 76
6 / 77
+ 78
1 / End 79
2 / 80
3 / PgDn 81
0 / Ins 82
. / Del 83

27

HOOFDSTUK 12 HOOFDSTUK 12 HOOFDSTUK 12 HOOFDSTUK 12 LUSSEN(1): FOR...NEXT LUSSEN(1): FOR...NEXT LUSSEN(1): FOR...NEXT LUSSEN(1): FOR...NEXT

WILT U DAT NOG EVEN HERHALEN?
Het komt geregeld voor dat bepaalde opdrachten vaker uitgevoerd moeten worden.
Zo is in opdracht 5 van hoofdstuk 2 een eenvoudig programma gemaakt dat circa
10 keer je naam op het scherm zet, door een aantal malen de opdracht PRINT
"Naam" in te typen. In opdracht 10 is dit programma aangepast door een lus
te gebruiken. Een eenvoudig programma dat het gehele scherm vult met je naam
zie je hier onder.

12.1 Eenvoudig gebruik van FOR...NEXT 12.1 Eenvoudig gebruik van FOR...NEXT 12.1 Eenvoudig gebruik van FOR...NEXT 12.1 Eenvoudig gebruik van FOR...NEXT
CLS
INPUT "Naam (niet meer dan 8 letters): ", Naam$
Naam$ = LEFT$(Naam$ + STRING$(8, 32), 8) '8 spaties toevoegen
CLS 'en eerste 8 karakters nemen
FOR i = 1 TO 250
PRINT Naam$;
NEXT i
END

Na invoer van je naam, wordt deze aangepast. Er wordt voor gezorgd dat Naam$
uit precies 8 karakters bestaat. De naam past dan 250 keer (10 per regel en
totaal 25 regels) op het scherm. Hiertoe wordt Naam$ aangevuld met acht spaties
(STRING$(5, 32), waarbij 32 de ASCIIwaarde voor een spatie is). Dit is nodig
voor het geval Naam$ uit nul karakters bestaat. Vervolgens worden de eerste
acht karakters van de naam genomen (LEFT$(.. , 8)). Dit kan ook op een andere
manier. Zie hiervoor de opdracht bij dit programma.
In de lus FOR...NEXT wordt met een teller i (of iedere andere variabele)
bijgehouden hoe vaak de lus is uitgevoerd. Iedere keer wordt i n groter.
De puntkomma (;) achter Naam$ zorgt ervoor dat de cursor op dezelfde regel
blijft.

Verander de regel Naam$ = LEFT$(Naam$ ... in:
Naam$ = Naam$ + SPACE$(8 LEN(Naam$)) en start opnieuw.
Kun je uitleggen waarom dit hetzelfde resultaat oplevert?

HOE WARM IS HET HIER EIGENIJK?
Stel je wilt een tabel maken waarin de temperatuurschalen van Celsius en
Fahrenheit met elkaar vergeleken worden (T C = 1.8 * T + 32 F). In de tabel
moet de schaal van Celsius onderverdeeld zijn in stukjes van 5. Ook hiervoor
kun je FOR...NEXT gebruiken in combinatie met STEP.

12. 12. 12. 12.2 22 2 Omrekenen van Celsius in Fahrenheit Omrekenen van Celsius in Fahrenheit Omrekenen van Celsius in Fahrenheit Omrekenen van Celsius in Fahrenheit
CLS
PRINT "Celsius Fahrenheit" 'weergave tabel
PRINT "--------------------"
REM Kan ook met: PRINT STRING$(20, 196) 'wordt etc.
M$ = " ### ###" 'bepaalt de lay out
FOR Celsius = -20 TO 40 STEP 5 'temperatuur met 5 graden omhoog
Fahrenheit = 1.8 * Celsius + 32 'omrekenformule
PRINT USING M$; Celsius; Fahrenheit 'getallen rechts uitgelijnd
NEXT Celsius
END

28

Verander het programma zodanig dat naar begin- en eindtemperatuur gevraagd
wordt en naar het interval (per hoeveel graden). Zorg er voor dat de gehele
tabel op een scherm past. (Gebruik dus variabelen in plaats van -20, 40 en
5).

WAT STA JIJ GEMIDDELD VOOR .... ?
Als je gegevens in een array (zie hoofdstuk 6) wilt stoppen is het gebruik
van FOR...NEXT erg handig. In het volgende programma worden toetscijfers met
hun gewichten ingelezen. Daarna wordt het gemiddelde getoond.

12.3 Bepalen van een gemiddeld eindcijfer 12.3 Bepalen van een gemiddeld eindcijfer 12.3 Bepalen van een gemiddeld eindcijfer 12.3 Bepalen van een gemiddeld eindcijfer
CLS
INPUT "Hoeveel cijfers invoeren: ", N
DIM Cijfer(N), Gewicht(N) 'array's dimensioneren
PRINT "Voer cijfer en gewicht als volgt in: cijfer, gewicht <Enter>"
PRINT
FOR i = 1 TO N 'start lus
PRINT "Nr."; i; ":"; 'bijhouden aantal cijfers
INPUT " ", Cijfer(i), Gewicht(i) 'gegevens invoeren
NEXT i
PRINT 'regel overslaan
Som = 0 'startwaarde voor Som
Deler = 0 'startwaarde voor Deler
FOR i = 1 TO N
Som = Som + Cijfer(i) * Gewicht(i) 'cijfers x gewichten optellen
Deler = Deler + Gewicht(i) 'totale aantal cijfers
NEXT i
Gem = Som / Deler 'berekent gemiddelde
PRINT "Gemiddelde:"; Gem 'gemiddelde tonen
PRINT "Afgerond: ";
PRINT USING "#.#"; Gem 'nu afgerond op n decimaal
END

In dit programma wordt twee keer dezelfde FOR...NEXT-lus gebruikt. Het is
mogelijk om slechts n lus te gebruiken. Verander het programma zodanig dat
er maar van een lus gebruik gemaakt wordt. Zorg er bovendien voor dat het
gemiddelde op twee decimalen wordt afgerond.

IN HET KADER VAN OVERZICHTELIJKHEID.
Op het scherm kun je tekst of gegevens overzichtelijk in een

of in een zetten

Voor kaders heb je karakters als , , , , , etc. nodig. De belangrijkste
volgen nu met hun ASCII-waarden.

218 196 194 191 201 205 203 187

179 186
197 180 206 185
195 204

192 196 193 217 200 205 202 188

K A D E R K A D E R
29

Een kader maak je met behulp van een FOR...NEXT-lus. In het volgende programma
zie je n van de manieren om dit voor elkaar te krijgen. Bij het maken van
de verticale randen gebruik je de FOR...NEXT-lus en daarbij maakt het nogal
uit of je de ruimte tussen de linker en rechter rand vult met spaties (met
de opdracht SPACE$) of niet (je moet dan LOCATE gebruiken). Als je namelijk
SPACE$ gebruikt, wordt alles tussen de randen gewist. Je kunt op die manier
niet ergens een kader omheen plaatsen. Je moet dan eerst het kader maken en
dit vervolgens opvullen. Bij het gebruik van LOCATE is dit niet nodig.
Het nu volgende programma is bedoeld als aardigheid, maar is ook zeer
instructief. Er wordt twintig keer een kader (enkel- of dubbelrandig) van
willekeurige grootte op een willekeurige plek op het scherm gezet. Uiteraard
moet hiervoor RND (random) gebruikt worden. Voor het tekenen van het kader
zijn slechts de cordinaten van de linker bovenhoek en de rechter benedenhoek
nodig. Deze cordinaten worden willekeurig bepaald en indien nodig verwisseld
(bijvoorbeeld linksboven = (12, 20) en rechtsonder = (3, 4) kan natuurlijk
niet, zodat de cordinaten verwisseld moeten worden). Dit verwisselen kan met
het commando SWAP. Stel A = 5 en B = 3 dan zorgt SWAP A, B er voor dat A =
3 en B = 5. Bovendien demonstreert dit programma het gebruik van een lus in
een lus.

12.4 Willekeurig kaders tekenen 12.4 Willekeurig kaders tekenen 12.4 Willekeurig kaders tekenen 12.4 Willekeurig kaders tekenen
CLS
RANDOMIZE TIMER
FOR i = 1 TO 20 'totaal 20 kaders
r = RND 'bepaalt rand (enkel of dubbel)
c = INT(RND * 14) + 2 'bepaalt de kleur (geen zwart)
COLOR c, 0
li = INT(RND * 75) + 1 'links (van 1 t/m 75)
bo = INT(RND * 20) + 1 'boven (van 1 t/m 20)
re = INT(RND * 72) + 8 'rechts (van 8 t/m 79)
be = INT(RND * 20) + 5 'beneden (van 5 t/m 24)
IF li > re THEN SWAP li, re 'verwissel li en re indien nodig
IF li = re THEN re = re + 1 'li en re mogen niet gelijk zijn
IF bo > be THEN SWAP bo, be 'verwissel bo en be indien nodig
IF bo = be THEN be = be + 1 'bo en be mogen niet gelijk zijn
Br = re - li + 1 'breedte van het kader
LOCATE bo, li 'begin bij linker bovenhoek
IF r < .5 THEN 'enkelrandig
PRINT CHR$(218); STRING$(Br - 2, CHR$(196)); CHR$(191);
FOR a = bo + 1 TO be - 1 'lengte van het kader
LOCATE a, li 'begin links
PRINT CHR$(179);
LOCATE a, li + Br - 1 'naar rechter rand
PRINT CHR$(179);
NEXT a
LOCATE be, li 'linker benedenhoek
ELSE 'dubbelrandig
PRINT CHR$(186);
PRINT CHR$(186);
NEXT a
END IF
30

SLEEP 1 'even wachten
NEXT i
COLOR 7, 0 'kleuren weer normaal
END

Programmas kun je korter maken door vergelijkbare opdrachten die vaker
voorkomen proberen samen te voegen. In bovenstaand programma komt twee keer
de opdracht voor om een kader te tekenen. De eerste keer bij een enkelrandig
kader en de tweede keer bij een dubbelrandig kader. Je kunt beide opdrachten
samenvoegen door van te voren vast te leggen welke karakters gebruikt moeten
worden. Hieronder staat zon programma, die natuurlijk nog veel overeen-
komsten heeft met programma 12.4.

12.5 Nogmaals willekeurig kaders tekenen 12.5 Nogmaals willekeurig kaders tekenen 12.5 Nogmaals willekeurig kaders tekenen 12.5 Nogmaals willekeurig kaders tekenen
CLS
RANDOMIZE TIMER
FOR i = 1 TO 20 'totaal 20 kaders
r = RND 'bepaalt rand (enkel of dubbel)
IF r < .5 THEN 'enkelrandig
libo$ = CHR$(218) 'linksboven
rebo$ = CHR$(191) 'rechtsboven
libe$ = CHR$(192) 'linksbeneden
rebe$ = CHR$(217) 'rechtsbeneden
hor$ = CHR$(196) 'horizontaal
ver$ = CHR$(179) 'verticaal
ELSE 'dubbelrandig
libo$ = CHR$(201) 'linksboven
rebo$ = CHR$(187) 'rechtsboven
libe$ = CHR$(200) 'linksbeneden
rebe$ = CHR$(188) 'rechtsbeneden
hor$ = CHR$(205) 'horizontaal
ver$ = CHR$(186) 'verticaal
END IF
c = INT(RND * 14) + 2 'bepaalt de kleur (geen zwart)
COLOR c, 0
li = INT(RND * 75) + 1 'links (van 1 t/m 75)
bo = INT(RND * 20) + 1 'boven (van 1 t/m 20)
re = INT(RND * 72) + 8 'rechts (van 8 t/m 79)
be = INT(RND * 20) + 5 'beneden (van 5 t/m 24)
IF li > re THEN SWAP li, re 'verwissel li en re indien nodig
IF li = re THEN re = re + 1 'li en re mogen niet gelijk zijn
IF bo > be THEN SWAP bo, be 'verwissel bo en be indien nodig
IF bo = be THEN be = be + 1 'bo en be mogen niet gelijk zijn
Br = re - li + 1 'breedte van het kader
LOCATE bo, li 'begin bij linker bovenhoek
PRINT libo$; STRING$(Br - 2, hor$); rebo$;
PRINT ver$;
PRINT ver$;
NEXT a
PRINT libe$; STRING$(Br - 2, hor$); rebe$;
SLEEP 1 'even wachten
NEXT i
COLOR 7, 0 'kleuren weer normaal
END
31

In feite kan het nog korter, door de betreffende ASCII-waarden in te lezen
met behulp van het commando READ en DATA. Dit staat in hoofdstuk 14.

12.5 Tekst in e 12.5 Tekst in e 12.5 Tekst in e 12.5 Tekst in een en en en kader plaats kader plaats kader plaats kader plaatsen en en en
Dit programma moet je zelf maken. Gebruik onderstaande aanwijzingen.
Dimensioneer de array Naam$() voor 10 elementen.
Laat met een FOR...NEXT-lus 10 namen opvragen en stop ze in Naam$().
Bepaal de lengte van de langste naam. Hint: Stel eerst de maximale lengte
op 0; bijv. MaxLen = 0. Bepaal dan van alle namen de lengte en vergelijk
ze met MaxLen. MaxLen moet de lengte van de string worden als die lengte
groter is dan de huidige waarde van MaxLen. Dus IF LEN(Naam$(i)) > MaxLen
THEN MaxLen = LEN(Naam$(i)).
Het kader moet links en rechts 2 karakters breder worden dan de langste
naam (waarvan de lengte inmiddels is vastgelegd in MaxLen).
Plaats het kader bij voorkeur midden op het scherm.
Laat dan de namen in het kader zetten.

Herschrijf een gedeelte van het programma zodat je eerst de namen op het scherm
zet en daar het kader omheen zet (dus net omgekeerd).

12.6 Tafel weergeven 12.6 Tafel weergeven 12.6 Tafel weergeven 12.6 Tafel weergeven
Neem het programma uit hoofdstuk 1 over.
Verander het programma zodanig dat de tafel in het midden van het scherm
komt te staan met een kader er omheen.
Wijzig dit ook weer zodat iedere seconde een tafel getoond wordt, beginnend
en eindigend bij wat je ingevoerd hebt.

32

HOOFDSTUK HOOFDSTUK HOOFDSTUK HOOFDSTUK 13 13 13 13 L LL LUSSEN USSEN USSEN USSEN (2): (2): (2): (2): D DD DO OO O...L ...L ...L ...LOO OO OO OOP PP P

EEN LOOPING MET DE PC.
In sommige gevallen moet een lus eindeloos' herhaald worden, of is vooraf
niet bekend hoe vaak de lus doorlopen moet worden. In zon geval is
FOR...NEXT niet erg geschikt en kun je beter DO...LOOP gebruiken.
Een oneindige lus is de volgende.

13.1 Ee 13.1 Ee 13.1 Ee 13.1 Een n n n oneindige lus met DO...LOOP oneindige lus met DO...LOOP oneindige lus met DO...LOOP oneindige lus met DO...LOOP
CLS
DO
x = x + 1
PRINT x
LOOP
PRINT "Klaar"
END

Je kunt het programma alleen maar stoppen met <Ctrl>-C of <Ctrl>-Break.
"Klaar" zal nooit getoond worden op deze manier.

Opdracht bij programma 13.1 Het beindigen van DO...L Het beindigen van DO...L Het beindigen van DO...L Het beindigen van DO...LO OO OOP. OP. OP. OP.
Gelukkig zijn er voldoende manieren om uit een lus te komen. Een onelegante
manier is het toevoegen van IF x = 10 THEN EXIT DO. Je kunt dus met EXIT DO
de lus verlaten.
Wijzig het programma zodat je met EXIT DO de lus verlaat.

Andere manieren zijn: DO WHILE x = 10 ... LOOP
DO UNTIL x = 10 ... LOOP
DO ... LOOP WHILE x = 10
DO ... LOOP UNTIL x = 10
Probeer bovenstaande vier manieren uit en let goed op hoe vaak de lus wordt
uitgevoerd.
Herhaal de vorige opdracht, maar voeg nu eerst onder de opdracht CLS de
volgende regel toe: x = 10. Zijn er nu verschillen te zien bij die vier
manieren? Let weer goed op hoe vaak de lus wordt uitgevoerd.
Hetzelfde als de vorige opdracht, maar gebruik nu ook eens x > 10, x >=
10, x < 10, x <= 10, x <> 10 en kijk weer hoe vaak de lus doorlopen wordt.

GA TERUG NAAR AF!
Een erg primitieve vorm van een lus is het gebruik van een label in combinatie
met de opdracht GOTO. In GWBASIC is dit vrij normaal, maar in QuickBASIC niet!
Met GOTO geef je een onvoorwaardelijke sprongopdracht naar een label. Zo'n
label kan een getal of een woord zijn, maar moet altijd eindigen met een dubbele
punt.

13.2 Het gebruik van GOTO label als (primitieve) lus 13.2 Het gebruik van GOTO label als (primitieve) lus 13.2 Het gebruik van GOTO label als (primitieve) lus 13.2 Het gebruik van GOTO label als (primitieve) lus
CLS
start: 'eerste label (eindigen met :)
x = x + 1
PRINT x
IF x = 10 GOTO verder 'naar tweede label om te stoppen
GOTO start 'terug naar start:
verder: 'tweede label
PRINT "Klaar!"
END

33

In hoofdstuk 12 kwam een lus in een lus voor. Dat kan ook bij DO...LOOP.

13.3. Invoer van n karakter zonder <Enter> 13.3. Invoer van n karakter zonder <Enter> 13.3. Invoer van n karakter zonder <Enter> 13.3. Invoer van n karakter zonder <Enter>
CLS
DO
DO
I$ = INKEY$ 'vraagt om toetsinvoer
LOOP UNTIL LEN(I$) 'als LEN(I$) > 0 dan verder
PRINT I$;
LOOP UNTIL I$ = CHR$(27) 'stoppen als <Esc> is ingetoetst
END

De tweede lus is erg belangrijk. Met I$ = INKEY$ wordt naar een toetsindruk
gevraagd, maar hier wordt niet op gewacht (zoals bij INPUT$()). Daarom moet
deze opdracht in een lus staan. Met LOOP UNTIL LEN(I$) wordt bepaald of er
een toets is ingedrukt. Zo ja, dan heeft I$ een bepaalde lengte, namelijk
1, en wordt de lus verlaten. Ook goed zou zijn: LOOP UNTIL LEN(I$) > 0, maar
kennelijk is de toevoeging > 0 niet nodig.
Als je moet kiezen tussen Ja of Nee, kun je de lus als volgt wijzigen:

DO
I$ = UCASE$(INKEY$)
LOOP UNTIL I$ = "J" OR I$ = "N"

Het maakt, door de opdracht UCASE$, niet uit of je een hoofdletter of een kleine
letter invoert.

Je kunt maar op n manier uit de hoofdlus van programma 13.3 komen, namelijk
door het invoeren van CHR$(27). Dit kun je op twee manieren invoeren via het
toetsenbord:
1. houdt de <A1t>toets ingedrukt en toets op het numerieke toetsenbord 27 in;
(het numerieke toetsenbord is het gedeelte rechts op het toetsenbord)
2. (veel en veel simpeler) druk op <Esc>.

Veel programma's kun je beindigen door op <Esc> te drukken.

Start het programma en voer gegevens in via ALT en numerieke toetsenbord,
zoals hierboven voor CHR$(27) beschreven is. Je kunt hiermee karakters op
het scherm krijgen die niet op het toetsenbord staan. Probeer maar eens
met waarden tussen 126 en 254.
Zoek uit bij welke waarden tussen O en 32 er GEEN karakter op het scherm
wordt getoond.
Wat stellen de getallen precies voor die je in combinatie met de ALT-toets
moet invoeren?

HET GEHELE SCHERM OVER.
Hoofdstuk 11 ging over het gebruik van bijzondere toetsen. Dit wordt nu
gebruikt om een blokje over het gehele scherm te laten bewegen. Maar er gelden
ook randvoorwaarden. Het blokje moet bijvoorbeeld wel op het scherm blijven.
Hieronder staat een overzicht van alle eventuele probleemgevallen en een
(mogelijke) oplossing.

34

Probleem: Oplossing:

Programma stoppen Druk op <Esc>
Blokje op het scherm krijgen PRINT CHR$(219);
(ook op de onderste regel) (vandaar ;)
Blokje wissen PRINT " ";
Positie van het blokje x = kolom en y = regel
Positie op het scherm LOCATE x, y
Positie veranderen x = x + 1, x = x - 1; idem voor y
Blokje op scherm houden IF x < 1 THEN ...; IF x > 80 THEN ...
IF y < 1 THEN ...; IF y > 25 THEN ...

Wat betreft dit laatste, moet nog de keuze gemaakt worden of het blokje moet
"doorlopen" of niet. In het voorbeeld mag het blokje "doorlopen", dus als het
blokje links verdwijnt, komt het rechts weer tevoorschijn. Het blokje mag ook
schuin over het scherm. Hiervoor kunnen de toetsen <Home>, <End>, <PgUp> en
<PgDn> op het numerieke toetsenbord gebruikt worden. Dit betekent dat zowel
x als y moet veranderen.

13.4 Het bewegende blokje 13.4 Het bewegende blokje 13.4 Het bewegende blokje 13.4 Het bewegende blokje
CLS
LOCATE 12, 40 'midden van scherm
PRINT CHR$(219); 'print een blokje
x = 40 'beginwaarde x-cordinaat (kolom)
y = 12 'beginwaarde y-cordinaat (regel)
DO
DO
i$ = INKEY$
LOOP UNTIL LEN(i$) 'wachten op toetsinvoer
IF LEN(i$) = 1 THEN
Waarde = ASC (i$) 'gewone toets
ELSE
Waarde = -ASC(RIGHT$(i$, 1)) 'bijzondere toets
END IF
LOCATE y, x
PRINT " " 'blokje wissen

SELECT CASE Waarde 'cordinaten wijzigen
CASE -72 'pijl omhoog
y = y - 1 'n regel hoger
CASE -80 'pijl omlaag
y = y + 1 'n regel lager
CASE -75 'pijl naar links
x = x - 1 'plaatsje naar links
CASE -77 'pijl naar rechts
x = x + 1 'plaatsje naar rechts
CASE -71 '<Home>
x = x - 1 'n naar links
y = y - 1 'n naar boven
CASE -79 '<End>
x = x - 1 'n naar links
y = y + 1 'n naar beneden
CASE -73 '<PgUp>
x = x + 1 'n naar rechts
y = y - 1 'n naar boven
CASE -81 '<PgDn>
x = x + 1 'n naar rechts
y = y + 1 'n naar beneden
35

CASE 27 'op <Esc> gedrukt
CLS : END 'stoppen
END SELECT
IF y < 1 THEN y = 25 '
IF y > 25 THEN y = 1 'zorgen dat x en y "binnen
IF x < 1 THEN x = 80 'de perken" blijven.
IF x > 80 THEN x = 1
LOCATE y, x
PRINT CHR$(219);
LOOP

NOG EEN (K)LUS.
Er is nog een lus. Deze begint met WHILE en eindigt met WEND. Deze lus komt
overeen met een DO WHILE ... LOOP-constructie, maar kan echter niet met EXIT
worden verlaten. Meestal wordt WHILE...WEND in het volgende geval gebruikt:

13.5 Wachte 13.5 Wachte 13.5 Wachte 13.5 Wachten totdat een toets is ingedrukt n totdat een toets is ingedrukt n totdat een toets is ingedrukt n totdat een toets is ingedrukt
CLS
PRINT "Druk op een toets om verder te gaan."
WHILE INKEY$ = "": WEND

Zolang er niets ingevoerd is geldt INKEY$ = "", waarbij "" staat voor: geen
invoer. In dat geval geeft WEND aan dat je weer terug moet keren.
Hetzelfde kan bereikt worden met de DO...LOOP-constructie zoals beschreven
in dit hoofdstuk. In principe kun je DO...LOOP altijd gebruiken in plaats van
WHILE...WEND.

36

HOOFDSTUK HOOFDSTUK HOOFDSTUK HOOFDSTUK 14 14 14 14 GEG GEG GEG GEGE EE EVENS VENS VENS VENS INV INV INV INVO OO OEREN EREN EREN EREN ( (( (2) 2) 2) 2)

LEES DE DATA.
In hoofdstuk 7 heb je geleerd hoe gegevens vanaf het toetsenbord kunnen worden
ingevoerd. Het komt ook voor dat gegevens als 'constanten' worden gebruikt.
In een programma dat alle dagen van de week gebruikt, zal er niet gevraagd
worden deze zelf in te voeren. Meestal komen deze dagen in een stringarray
te staan. Dit kun je vrij primitief doen: Dag$(1) = "Zaterdag" etc.
Handiger is het om de gegevens als DATA in je programma op te nemen en ze met
de opdracht READ te laten inlezen. De DATA kunnen zowel aan het begin als aan
het eind van het programma staan.

14.1 DATA inlezen m.b.v. READ 14.1 DATA inlezen m.b.v. READ 14.1 DATA inlezen m.b.v. READ 14.1 DATA inlezen m.b.v. READ
CLS
DIM Dag$(7) 'array dimensioneren
FOR i = 1 to 7
READ Dag$(i) 'gegevens achter DATA een voor een inlezen
NEXT i

FOR i = 1 TO 7
PRINT Dag$(i) 'ter controle of het gelukt is
NEXT i

DATA "Maandag", "Dinsdag", "Woensdag", "Donderdag"
DATA "Vrijdag", "Zaterdag", "Zondag"

Zoek uit wat er mis gaat als je i tot 8 of hoger laat lopen.
Zoek uit wat er mis gaat als je geen aanhalingstekens gebruikt bij de DATA.
Controleer of het programma ook loopt als je alle DATA aan het begin van
het programma plaatst. Hoe kun je deze regels het snelst verplaatsen?

Datum en tijd kunnen worden opgevraagd met DATE$ en TIME$. Als je de datum
opvraagt met bijvoorbeeld Datum$ = DATE$, dan wordt 28 maart 2013 weergegeven
als 03-28-2013. Met MID$, LEFT$ e.d. kun je dit omzetten in 28-03-2013 en zelfs
in 28 maart 2013. Voor dat laatste moet je wel een stringarray dimensioneren
waarin alle namen van de maanden komen te staan (net zo als het in programma
14.1 is gedaan voor de dagen in de week). Het programma kan er dan als volgt
uit komen te zien:

14.2 DATA inlezen m.b.v. READ 14.2 DATA inlezen m.b.v. READ 14.2 DATA inlezen m.b.v. READ 14.2 DATA inlezen m.b.v. READ
CLS
DIM Maand$(12) 'array voor de maanden dimensioneren
FOR i = 1 TO 12
READ Maand$(i) 'gegevens achter DATA een voor een inlezen
NEXT i
Datum$ = DATE$ 'systeemdatum ophalen: mm-dd-yyyy
Dag$ = MID$(Datum$,4,3) 'dag halen uit datum
Mnd = VAL(LEFT$(Datum$,2)) 'maandwaarde halen uit datum
Jaar$ = RIGHT$(Datum$,5) 'jaar halen uit datum
Datum$ = Dag$ + Maand$(Mnd) + Jaar$
PRINT Datum$

DATA "Januari", "Februari", "Maart", "April"
DATA "Mei", "Juni", "Juli", "Augustus"
DATA "September", "Oktober", "November", "December"
37

HOOFDSTUK 15 HET LEZEN EN HET SCHRIJVEN VAN EEN BESTAND OP DE SCHIJF HOOFDSTUK 15 HET LEZEN EN HET SCHRIJVEN VAN EEN BESTAND OP DE SCHIJF HOOFDSTUK 15 HET LEZEN EN HET SCHRIJVEN VAN EEN BESTAND OP DE SCHIJF HOOFDSTUK 15 HET LEZEN EN HET SCHRIJVEN VAN EEN BESTAND OP DE SCHIJF

Als gegevens uit een bestand moeten worden gelezen kan dat op twee manieren:
1. van begin tot eind (je hebt dan een sequentile file)
2. in willekeurige volgorde (je hebt dan een random access file)
Hier gaat het vooral om de sequentile file.

Als gegevens naar een bestand moeten worden geschreven, kan dit ook weer op
twee manieren (bij een sequentile file dus):
1. alles over de reeds bestaande gegevens schrijven (voor zover aanwezig)
2. alles achter de reeds bestaande gegevens zetten (voor zover aanwezig)
Een voorbeeld van 1. is een bestand met gemiddelden van cijfers. Als er nieuwe
cijfers zijn, worden de gemiddelden anders en moeten ze over de oude gegevens
worden geschreven.
Een voorbeeld van 2. is een bestand met gegevens over personen. Als er meer
personen bij komen, moeten de gegevens aan het bestand worden toegevoegd.
(Opmerking: voor het wijzigen van gegevens kun je het handigst gebruik maken
van een random access file, omdat je dan op een bepaalde plaats in het bestand
veranderingen kan aanbrengen. Als je geen random access file gebruikt, moet
je om iets te wijzigen eerst het gehele bestand inlezen, dan veranderingen
aanbrengen en dan alles weer wegschrijven.)

BESTANDEN EERST OPENEN.
Voordat je iets kunt doen met een bestand, moet het worden geopend. Dit gebeurt
met het commando OPEN. Bij sequentile files heb je de volgende drie
mogelijkheden:
OPEN "bestandnaam" FOR INPUT AS #n lezen van gegevens
OPEN "bestandnaam" FOR OUTPUT AS #n schrijven van gegevens
OPEN "bestandnaam" FOR APPEND AS #n toevoegen van gegevens
Hierin is #n het nummer van het bestand. Dit nummer varieert van 1 tot 255.
Je kunt dus een aantal bestanden tegelijkertijd geopend hebben. Ieder bestand
heeft zijn eigen nummer.

Het schrijven naar een bestand.
Tijdens het openen wordt het nieuwe bestand automatisch gemaakt op de schijf.
Als het bestand reeds bestaat, zal met OUTPUT de inhoud verloren gaan en zullen
met APPEND gegevens worden toegevoegd.
Voor het schrijven naar een bestand zijn twee commando's beschikbaar:
WRITE #n gegevens worden gestructureerd naar de file geschreven
nieuwe gegevens komen op een volgende regel in de file
gegevens op regel worden gescheiden door komma's
strings worden tussen aanhalingstekens gezet
voorbeeld: WRITE #1, "Jopie", 34 staat in file als; "Jopie",34
WRITE #1, "Anna", 28 staat in file als; "Anna",28
PRINT #n gegevens worden achter elkaar gezet, zonder scheidingstekens
nieuwe gegevens komen op een volgende regel in de file
strings worden niet tussen aanhalingstekens gezet
voorbeeld: PRINT #1, "Jopie"; 34 staat in file als; Jopie 34
PRINT #1, "Anna"; 28 staat in file als; Anna 28
Opmerking; Als je een komma(,) gebruikt in plaats van een puntkomma (;), wordt
TAB(14) gebruikt.
Vergelijk dit met het gewone PRINT A; B en PRINT A, B.

38

In het volgende programma wordt een bestand opgeslagen waarin gegevens van
personen staan. Deze gegevens zijn: de naam en de leeftijd. Eerst worden deze
gegevens via het toetsenbord ingevoerd en opgeslagen in de array Naam$() en
Leeftijd(). Vervolgens wordt het bestand opgeslagen als PERSOON.DAT.

Opmerking: De drie letters achter de punt vormen de extensie. Hiermee kun je
aangeven om wat voor soort bestand het gaat. Hieronder volgt een overzicht
van een aantal veelgebruikte extensies met hun betekenis.
.BAK Reservekopie van een bestand (BAcKup)
.BAS Programmabestand in BASIC (BASic)
.DAT Bestand met gegevens (DATa)
.DOC Tekstbestand (DOCument)
.EXE Direct uitvoerbaar programmabestand (EXEcute)
.HLP Bestand met hulpinformatie (HuLP)
.TXT Tekstbestand (TeXT)

15.1 Een bestand schrijven naar de schijf 15.1 Een bestand schrijven naar de schijf 15.1 Een bestand schrijven naar de schijf 15.1 Een bestand schrijven naar de schijf
CLS
FOR i = 1 TO 5 'gegevens invoeren vanaf
PRINT "Persoon"; i 'het toetsenbord
INPUT "Naam: ", Naam$(i)
INPUT "Leeftijd: ", Leeftijd(i)
PRINT
NEXT i

OPEN "PERSOON.DAT" FOR OUTPUT AS #1 'PERSOON.DAT openen voor schrijven
FOR i = 1 TO 5
WRITE #1, Naam$(i), Leeftijd(i)
NEXT i
CLOSE #1 'hiermee sluit je bestand #1
END

Het is ook mogelijk om naar de naam van het bestand te vragen (bijvoorbeeld
met INPUT Bestand$) en dan het bestand te openen met:
OPEN Bestand$ FOR .... (etc).
Let op dat hier WRITE gebruikt wordt. Hierdoor worden strings tussen ""
gezet. Bij het inlezen van de gegevens in programma 15.2 voorkom je zo
problemen. Probeer maar eens met PRINT #1. Je zult merken dat je in programma
15.2 foutmeldingen krijgt.

Experimenteer met een andere manier om de gegevens vanaf het toetsenbord
in te voeren. Met andere woorden: maak je eigen lay-out.

Het lezen van een bestand.
Als een bestand voor lezen geopend wordt, moet het wel bestaan. Anders krijg
je de foutmelding "File not found".
Voor het lezen van gegevens zijn maar liefst drie commando's beschikbaar;
INPUT$ #n Hiermee lees je een aantal karakters uit bestand #n.
Voorbeeld: Invoer$ = INPUT$(20, #1).
Met deze opdracht worden 20 karakters uit bestand #1 gelezen.
Als de opdracht een aantal malen herhaald wordt, worden steeds
de volgende 20 karakters ingelezen. Enzovoort. Alle soorten
karakters uit het bestand worden ingelezen, dus ook karakters
die niet op het scherm getoond kunnen worden.

39

INPUT #n Hiermee kun je zowel stringvariabelen als numerieke
variabelen inlezen. Als een stringvariabele ingelezen moet
worden, stopt de invoer zodra er een komma, een carriage
return (CHR$(13)) of een line feed (CHR$(10)) gelezen wordt.
Voorbeeld: Een bestand bevat de volgende tekst: Hallo, hoe
gaat het met jou?
Als je deze tekst wilt inlezen met INPUT #1, Tekst$, geldt
dat Tekst$ = "Hallo", want de invoer stopt direct bij de komma.
Er worden wel komma's gelezen door INPUT #n als in het bestand
de tekst tussen aanhalingstekens staat.
Voorbeeld: Een bestand bevat de volgende letterlijke tekst:
"Hallo, hoe gaat het met jou?"
Nu zal na inlezen met INPUT #1, Tekst$ gelden: Tekst$ = "Hallo,
hoe gaat het met jou?".
De aanhalingstekens kun je in het bestand krijgen door tekst
weg te schrijven met WRITE #n, maar er is nog een derde
leescommando waarbij dit niet nodig is.
LINE INPUT #n Hiermee wordt tekst, inclusief leestekens, ingelezen tot aan
een carriage return (CHR$(13)) en line feed (CHR$(10)), of
totdat er 255 tekens ingelezen zijn.

Je kunt dus zowel getallen als tekst (strings) lezen. Als je precies weet
hoeveel gegevens er in het bestand staan, kun je ze allemaal met een
FOR...NEXT-lus inlezen. Als je er meer wilt inlezen krijg je de foutmelding
"Input past end of file". Je kunt dan beter de ingebouwde functie EOF(#n)
gebruiken (EOF = End Of File). Er wordt dan automatisch bijgehouden wanneer
alle gegevens ingelezen zijn.

In het volgende programma wordt PERSOON.DAT gebruikt om gegevens in te lezen.

15.2 Een bestand lezen van de schijf 15.2 Een bestand lezen van de schijf 15.2 Een bestand lezen van de schijf 15.2 Een bestand lezen van de schijf
CLS

OPEN "PERSOON.DAT" FOR INPUT AS #1 'Openen voor lezen
FOR i = 1 TO 5 'Het bestand "bevat" 5 personen
INPUT #1, Naam$(i) 'Inlezen van de naam
INPUT #1, Leeftijd(i) 'Inlezen van de leeftijd
NEXT i
CLOSE #1 Hiermee wordt bestand #1 gesloten

FOR i = 1 TO 5 'Gegevens op het scherm zetten.
PRINT "Persoon ";i; " :";
PRINT TAB(13); Naam$(i)
PRINT TAB(13); Leeftijd(i); " jaar"
PRINT
NEXT i
END

Opmerkingen bij programma 15.2:
Ook goed zou zijn: INPUT #1, Naam$(i), Leeftijd(i)
Maar FOUT is: INPUT #1, Leeftijd(i), Naam$(i)
(Snap je waarom?)
Met CLOSE (zonder nummer) worden alle geopende bestanden gesloten.

40

Als het aantal personen onbekend is, gebruik je EOF(#n) in plaats van
FOR...NEXT:

DO WHILE NOT EOF(#1) 'Doe, zolang het einde nog niet bereikt is, ..
INPUT #1, Naam$(x), Leeftijd(x)
x = x + 1
LOOP

EOF staat voor End Of File.

Ook voor het lezen kun je naar de naam van het bestand vragen:
INPUT "Naam van het bestand: ", Bestand$
OPEN Bestand$ FOR INPUT ..... (etc)

Opmerking:
Als je de naam van het bestand niet meer weet, kun je met de opdracht FILES
alle bestanden op het scherm krijgen. Als je alle bestanden in C:\QB45\DATA
met extensie .TXT wilt zien, type je in:
* <F6> je komt dan in de Direct Mode; het gedeelte onder Immediate
* FILES "C:\QB45\DATA\*.TXT" gevolgd door <Enter>
* een willekeurige toets om weer in de Direct Mode te komen.
* <F6> om weer terug te keren naar het programmeerscherm

Een ander formaat voor het openen van bestanden is:
OPEN "I", 1, "naam" voor Input (lezen)
OPEN "O", 1, "naam" voor Output (schrijven)
OPEN "A", 1, "naam" voor Append (toevoegen)

41

HOOFDSTUK 16 ZELF PROGRAMMA'S MAKEN (2) HOOFDSTUK 16 ZELF PROGRAMMA'S MAKEN (2) HOOFDSTUK 16 ZELF PROGRAMMA'S MAKEN (2) HOOFDSTUK 16 ZELF PROGRAMMA'S MAKEN (2)

1 Schrijf een programma dat m.b.v. een FOR...NEXT-lus om 5 namen vraagt
en ze in een array plaatst (de array Naam$() bijvoorbeeld).
Maak het scherm schoon en zet de ingevoerde namen in omgekeerde volgorde
op het scherm met zwarte tekst op een witte achtergrond.

2 Wijzig het programma van opdracht 1, zodat de ingevoerde namen alfa-
betisch gesorteerd worden en dan op het scherm worden gezet. Hint: een
eenvoudige sorteermethode kun je maken met twee FOR...NEXT-lussen in
elkaar. De eerste laat je lopen van 1 tot 4 (FOR j = 1 TO 4) en de tweede
van j + 1 tot 5 (FOR i = j + 1 TO 5). Daarna vergelijk je twee namen (de
ene met index i en de andere met j) en verwissel ze indien nodig: IF
Naam$(j) > Naam$(i) THEN SWAP Naam$(j), Naam$(i).

3 Wijzig het programma van opdracht 2, zodat de ingevoerde namen gesorteerd
worden op lengte en dan op het scherm worden gezet.

4 Maak een programma waarbij je een cijfer tussen 0 en 9 moet invoeren.
De invoer moet direct geaccepteerd worden (dus GEEN <Enter> na de invoer),
maar moet wel op juistheid gecontroleerd worden (iets anders dan 0 t/m
9 invoeren mag niet). Gebruik SELECT CASE om bij ieder ingevoerd cijfer
een bepaalde mededeling op het scherm te zetten. Het programma moet
stoppen als je 0 invoert.

5 Schrijf een programma dan om 5 getallen vraagt. Maak er positieve gehele
getallen van en bepaal welke deelbaar zijn door 3.
Hint: als een getal deelbaar is door 3, dan is de rest na een integerdeling
gelijk aan 0, dus gebruik zoiets als IF x MOD 3 = 0 THEN ...

6 Pas het programma van opdracht 5 aan, zodat van de 5 getallen alleen de
grootste en de kleinste worden getoond.
Hint: het grootste getal vind je snel door een klein getal (Max = 0) te
vergelijken met de ingevoerde getallen en te verwisselen indien nodig.

7 Pas het programma van opdracht 6 aan, zodat je door invoer van G of K
zelf kunt bepalen of je het grootste (G) of het kleinste (K) getal wilt
zien.

8 Maak een programma waarbij een tekst moet worden ingevoerd. Daarna moet
die tekst achterste voren op het scherm worden afgedrukt. Voorbeeld:
Hallo, hoe gaat het teh taag eoh ,ollaH

9 Schrijf een programma waarbij een tekst wordt ingevoerd en laat daarna
op het scherm afdrukken hoeveel letters e er in die tekst voorkomen.

10 Verander het programma van opdracht 9 zodanig, dat van de ingevoerde tekst
de letters e in de tekst als punten worden weergegeven. Dus: Deze week
geen huiswerk D.z. w..k g..n huisw.rk

11 Wijzig het programma van opdracht 10 zodanig, dat nu alleen de letters
e worden weergegeven en de overige letters als punten. Dus: Deze week
geen huiswerk .e.e .ee. .ee e..

12 Maak een programma dat in een tabel alle ASCII-karakters (voor zover
mogelijk) op het scherm zet met hun waarde. De karakters die niet getoond
kunnen worden, geef je weer met een spatie. Als alles niet op scherm past,
moet je de mogelijkheid inbouwen dat je door het drukken op bijvoorbeeld
42

de spatiebalk kunt wisselen tussen de twee tabellen (alles kan sowieso
in twee tabellen die elk 128 karakters bevatten). Met <Esc> moet je het
programma kunnen beindigen. De lay out van de tabel bepaal je helemaal
zelf.

13 Maak een programma dat steeds om een geheel getal vraagt (tussen -32768
en + 32768) en om een deler vraagt. Bepaal dan of het getal deelbaar is
door die deler. Hint: de rest na de deling moet dan 0 zijn. Hierna moet
je met <Enter> door kunnen gaan en met <Esc> stoppen.

14 Schrijf een programma dat steeds om een geheel getal vraagt en bepaalt
of dit getal een priemgetal is (het is dan nergens door deelbaar, behalve
door 1 en door zichzelf). Ook nu geldt weer: <Enter> voor doorgaan en
<Esc> voor stoppen. Hint: als je van bijvoorbeeld 83 moet bepalen of het
een priemgetal is, hoelang ga je dan door met het ophogen van de deler?

15 Wijzig het programma van opdracht 14, zodat nu alle priemgetallen tussen
1 en 1000 naast elkaar op het scherm worden gezet (gebruik de opdracht
PRINT USING "####"; priem;). Onderzoek alleen de oneven getallen. Als
je bekend bent met de Zeefmethode van Erathostenes kun je het programma
erg snel maken. Bij deze methode worden alle 3-, 5-, 7-vouden (etc)
weggestreept uit alle oneven getallen tussen 1 en 1000. De getallen die
dan over blijven zijn de priemgetallen.

16 Pas het programma van opdracht 15 aan, zodat nu alle priemgetallen kunnen
worden weggeschreven in een bestand op de schijf.

17 Maak een programma dat bepaalt welke reeks van opeenvolgende getallen
als som 100 oplevert. Voorbeeld: de reeks 4+5+6+7+8+9 heeft als som 39
en de reeks 20+21+22+23 heeft als som 86.

18 Verander het programma van opdracht 17 zodanig dat je eerst kunt invoeren
wat de som moet zijn.

19 Bij wiskunde heb je de stelling van Phytagoras geleerd; a
2
+ b
2
= c
2
. In
bepaalde gevallen geldt deze formule voor gehele getallen: 3
2
+4
2
=5
2
. We
spreken dan van Phytagorese drietallen.
Schrijf een programma dat deze drietallen bepaalt en op het scherm zet.
Hint: Werk hier van rechts naar links. Dus laat c oplopen van 1 tot een
bepaald maximum en bepaal of c
2
te schrijven is als een som van twee
kwadraten. Laat a en b in twee FOR...NEXT lussen oplopen totdat a > b
(anders krijg je bij c = 5 ook als resultaat: 4
2
+3
2
=5
2
). Zodra geldt dat
a
2
+ b
2
= c
2
zet je dit volledig op het scherm. Het kwadraatje heeft als
ASCII-waarde 253.

20 Maak een programma dat van een ingevoerd getal alle delers op het scherm
zet. Na een invoer van bijvoorbeeld 10140, moet het volgende op het scherm
komen: 10140 =1x2x2x3x5x13x13.

De volgende programma's zijn wat moeilijker te programmeren. Je kunt je
nu echt gaan uitleven en alles zo fraai mogelijk maken. Natuurlijk mag
je alles ook simpel en sober houden, maar eigenlijk geldt:

M A A K E R W A T M O O I S V A N !

43

21 Schrijf een programma waarbij je de volgende gegevens moet invoeren:
beginkapitaal (in euro), rente (in procenten), aantal jaren (maximaal
20). Ieder jaar wordt bij het kapitaal de rente bijgeschreven
(samengesteld interest).
Voorbeeld; 1000,00 met 5% rente wordt na 1 jaar 1050,00; na 2 jaar
1102,50 (1050+5% van 1050); na 3 jaar 1157,63 (1102,50+5% van 1102,50).
Het programma moet deze gegevens netjes in een tabel op het scherm
afdrukken met een kader er omheen.
Hint: probeer een formule te bedenken (of op te zoeken) waarmee je het
kapitaal na ieder jaar snel kunt berekenen.

22 Ken je het spel Roulette? Zo ja, dan ga je een programma schrijven waarmee
je kunt uitzoeken of de nu volgende methode geschikt is om schatrijk te
worden! Je begint met bijvoorbeeld 100,=. Je kiest voor het gehele spel
n kleur uit (rood of zwart). De eerste inzet is 1,= op die kleur. Wat
je daarna inzet wordt als volgt bepaald: als je wint (je krijgt dan je
ingezette bedrag uitbetaald) blijft de inzet ongewijzigd, maar als je
verliest (je bent dan je ingezette bedrag kwijt) VERDUBBEL je de inzet.
Bepaal zelf hoe lang je dit wilt spelen.

23 Maak een programma waarmee je het volgende kaartspel kunt spelen: voor
je ligt een stapel met 52 speelkaarten. Alleen de bovenste kaart is
zichtbaar. Je moet raden of de volgende kaart hoger of lager is dan de
zichtbare kaart. Spreek met je zelf af of je alleen kijkt naar de waarde
of ook naar de kleur. Als ook de kleur meetelt, geldt de volgende volgorde:
schoppen > harten > ruiten > klaver. Als je juist raadt, krijg je punten
(of geld). Van te voren moet je kunnen inzetten.

Het moeilijkste in dit programma is de manier om 52 kaarten op te slaan
in array en om de kaarten te schudden. De simpelste manier is om alle
kaarten een waarde te geven lopend van klaver aas (nr. 1) tot schoppen
heer (nr. 52) en hier willekeurig een kaart uit te kiezen (met RND).
Probleem hierbij is: hoe bepaal je dat kaart nr. 33 een harten 7 is? Deel
33 door 13 met een integerdeling (33 \ 13 = 2). De 2 hoort dan bij harten.
De rest 33 - 2*13 (of 33 MOD 13) is de waarde. Denk er aan dat je iedere
kaart maar n keer kunt kiezen. Geef daartoe de gekozen kaart de waarde
0. (Dit is de meest primitieve manier. Bedenk een betere!)

Hoe zet je de kaarten op het scherm? Het simpelste is weer de waarden
als cijfers weer te geven (Aas=1, Boer=11, Vrouw=12, Heer=13) en de
kleuren als letters of woorden. Mooier (en moeilijker te programmeren)
is als je Aas als A of Aas weergeeft etc. De kleuren kun je ook met
tekentjes weergeven: hart = CHR$(3), ruit = CHR$(4), klaver = CHR$(5)
en schoppen = CHR$(6).

24 Schrijf een programma waarmee je MASTERMIND kunt spelen. Kies 4 getallen
uit een reeks van 6. Laat de computer de combinatie van 4 getallen bedenken
en ook de aanwijzingen geven. Bijvoorbeeld 1 = juiste cijfer en juiste
plaats; 0 is alleen juiste cijfer.

44

HOOFDSTUK 17 HOOFDSTUK 17 HOOFDSTUK 17 HOOFDSTUK 17 GRAFISCHE MOGELIJKHEDEN (1): INLEIDING EN LIJNEN GRAFISCHE MOGELIJKHEDEN (1): INLEIDING EN LIJNEN GRAFISCHE MOGELIJKHEDEN (1): INLEIDING EN LIJNEN GRAFISCHE MOGELIJKHEDEN (1): INLEIDING EN LIJNEN

DE SCHERMEN VAN EEN PC
Tot dusver is er steeds met een scherm gewerkt waarop uitsluitend tekst
geplaatst kan worden. We spreken dan van een tekstscherm. Nu kent BASIC ook
een aantal grafische schermen. Het verschil tussen een tekstscherm en een
grafisch scherm is dat een tekstscherm is opgebouwd uit 25 regels en 80
kolommen en een grafisch scherm is opgebouwd uit punten (pixels). Hoe meer
punten een grafisch scherm bevat, des te hoger is de resolutie en des te
'fijner worden de grafische voorstellingen. Het gewenste scherm kies je met
de opdracht SCREEN x. De keuze voor een grafisch scherm hangt af het aantal
pixels, het aantal mogelijke kleuren (van voor- en of achtergrond) en van de
weergave van tekst op het scherm. Met de grafische adapters van tegenwoordig
komen de volgende schermen in aanmerking:

scherm tekstformaat grafisch formaat

SCREEN 0 80 x 25 niet grafisch
SCREEN 12 80 x 30 640 x 480 pixels
SCREEN 13 40 x 25 320 x 200 pixels

Met SCREEN 13 heb je de meeste mogelijkheden om kleuren te variren. Voor de
programmas in deze cursus is SCREEN 12 goed.

HET ENE SCHERM IS HET ANDERE NIET
De cordinaten van een scherm beginnen standaard linksboven met (0,0). Met
SCREEN 12 heb je dan rechts beneden de cordinaten (639, 479). Bij het tekenen
van grafieken is het handig als je zelf de cordinaten van het scherm kunt
vastleggen. Dat kan met de opdracht WINDOW. Voor het tekenen van een grafiek
met een verticale as (y-as) van -5 tot 10 en een horizontale as (x-as) van
-4 tot 4 kan de opdracht WINDOW (-4, -5) (4, 10) gebruikt worden. Op deze
manier ligt het punt (-4, -5) links beneden en (4, 10) rechts boven.

Lijnen tekenen kan met de opdracht LINE.

17.1 Lijnen tekenen 17.1 Lijnen tekenen 17.1 Lijnen tekenen 17.1 Lijnen tekenen
SCREEN 12
CLS
FOR X = 0 TO 450 STEP 10
LINE (0, 0)-(600, X) 'lijn trekken van ... naar
NEXT X 'van links boven naar rechts beneden
SLEEP 3 'even wachten voor tweede gedeelte
CLS
WINDOW (0, 0)-(639, 199) 'cordinaten aanpassen
menu:
CLS
COLOR 11
INPUT "Kies uit mogelijkheid 0 (stoppen), 1, 2, 3, 4, 5 of 6"; k
SELECT CASE k 'variaties in lijnen tekenen
CASE 0: END
CASE 1
LINE (X, 0)-(600, X), 7 'variatie 1
NEXT X
CASE 2
LINE (3 * X, 0)-(600, X), 7 'variatie 2
NEXT X
45

CASE 3
LINE (3 * X, 0)-(600, X), 7 'variatie 3
LINE (0, X)-(3 * X, 199), 7
NEXT X
CASE 4
LINE (0, X)-(639 - X, 0), 7 'variatie 4
LINE (X, 199)-(639, 199 - X), 7
NEXT X
CASE 5
LINE (X, X / 1.5)-(300 + X, 199 - X / 1.5), 7 'variatie 5
NEXT X
CASE 6
FOR Y = 0 TO 620 STEP 62
LINE (X, 0)-(620 - Y, 199), 7 'variatie 6
NEXT Y
NEXT X
END SELECT
GOTO menu
END

Start het programma met de code erbij en probeer iedere variatie te
begrijpen. Verander zonodig wat in de variaties en kijk wat het effect is.

SNEL EEN RECHTHOEK IN ELKAAR DRAAIEN
Als je vier lijnen met elkaar verbindt, kun je een rechthoek tekenen. Gelukkig
heeft de LINE-opdracht een ingebouwde functie om rechthoeken te tekenen. Je
geeft de cordinaten van linker bovenhoek en rechter benedenhoek en voegt een
B toe (van Block) op de volgende manier:

LINE (x1, y1) - (x2, y2), , B

Tussen de twee komma's kan een kleurwaarde ingevuld worden. De rechthoek kun
je 'dicht' maken door BF toe te voegen (Block Fill). Zie programma 17.2.

17.2 Een rechthoek tekenen 17.2 Een rechthoek tekenen 17.2 Een rechthoek tekenen 17.2 Een rechthoek tekenen
SCREEN 12
CLS
LINE (0, 0)-(150, 70), 3, B
LINE (200, 120)-(400, 180), 6, BF
END

46

HOOFDSTUK 18 HOOFDSTUK 18 HOOFDSTUK 18 HOOFDSTUK 18 GRAFISCHE MOGELIJKHEDEN (2): PSET GRAFISCHE MOGELIJKHEDEN (2): PSET GRAFISCHE MOGELIJKHEDEN (2): PSET GRAFISCHE MOGELIJKHEDEN (2): PSET

WE ZETTEN DE PUNTJES OP DE i
Als je een grafiek of kromme wilt weergeven op het scherm, is het prettig als
je dit met puntjes kunt doen in plaats van lijntjes. Met PSET (x, y) kun je
een punt zetten op de cordinaten x en y. Het programma 18.2 geeft een aantal
voorbeelden. Nieuw hierin is de opdracht GOSUB. Voor iedere grafiek moet het
assenstelsel aangepast worden. Deze herhaalde opdracht staat in een sub-
routine met de naam XYas. Na GOSUB XYas worden eerst de opdrachten uitgevoerd
die in de subroutine staan. Na RETURN keert het programma terug waar het
gebleven was. Een eenvoudig voorbeeld ter illustratie.

18.1 18.1 18.1 18.1 H HH Het gebruik van GOSUB et gebruik van GOSUB et gebruik van GOSUB et gebruik van GOSUB
CLS
PRINT "Hallo. Hoe gaat het?"
GOSUB Antwoord
SLEEP 1
PRINT "Ook goed."
END

Antwoord:
SLEEP 1
PRINT "Goed. En met jou?"
RETURN

Verwijder END en kijk wat dit oplevert. Verklaring?

Programma 18.2 maakt gebruik van een keuzemenu. Door het invoeren van een
cijfer kun je kiezen uit zes grafieken. Iedere programmastap zou je nu moeten
snappen. Het programma is vrij lang. Zorg er voor dat je geen fouten maakt
bij het intypen.

18.2 Voorbeelden van het gebruik van PSET. 18.2 Voorbeelden van het gebruik van PSET. 18.2 Voorbeelden van het gebruik van PSET. 18.2 Voorbeelden van het gebruik van PSET.
SCREEN 12
pi = ATN(1) * 4 'manier om pi te berekenen
DO
CLS
LOCATE 4
PRINT TAB(30); "Maak een keuze:"
PRINT TAB(30); "---------------"
FOR i = 1 TO 6
PRINT TAB(30); i; " grafiek"; i
NEXT i
PRINT TAB(31); "7 stoppen"
LOCATE 20, 8
PRINT "Druk op een toets als de grafiek klaar is."
DO
i$ = INKEY$
LOOP UNTIL i$ > "0" AND i$ < "8"
SELECT CASE i$
CASE "1"
x = -7: y = 2
GOSUB XYas
FOR x = -2 * pi TO 2 * pi STEP .05
y = SIN(x)
PSET (x, y)
NEXT x
47

CASE "2"
x = 22: y = 10
GOSUB XYas
FOR t = -5 * pi TO 5 * pi STEP .02
x = t * COS(t)
y = .5 * t * SIN(t)
PSET (x, y)
NEXT t
CASE "3"
x = 7: y = 1.5
GOSUB XYas
x = t * COS(t)
y = SQR(ABS (t)) / 2 * SIN(t)
PSET (x, y)
NEXT t
CASE "4"
x = 1.5: y = 1.5
GOSUB XYas
FOR t = 0 TO 2 * pi STEP .01
y = COS(4 * t) * COS(t)
x = 2 * SIN(t) * COS(t)
PSET (x, y)
NEXT t
CASE "5"
x = 1.5: y = 1.5
GOSUB XYas
FOR t = 0 TO 2 * pi STEP .005
y = COS(4 * t) * COS(t)
x = COS(4 * t) * SIN(t)
PSET (x, y)
NEXT t
CASE "6"
x = 3: y = 1
GOSUB XYas
y = SIN(4 * t) * COS(.5 * t)
x = t * SIN(t) * COS(t)
PSET (x, y)
NEXT t
CASE "7"
SCREEN 0: END
END SELECT
SOUND 100, 2
LOOP

XYas:
CLS
WINDOW (-x, -y)-(x, y)
LINE (-x, 0)-(x, 0)
LINE (0, -y)-(0, y)
RETURN

Opmerking:
SIN = sinus; COS = cosinus; ABS = absolute waarde; SQR = wortel
48

HOOFDSTUK 19 HOOFDSTUK 19 HOOFDSTUK 19 HOOFDSTUK 19 GRAFISCHE MOGELIJKHEDEN (3): DRAW GRAFISCHE MOGELIJKHEDEN (3): DRAW GRAFISCHE MOGELIJKHEDEN (3): DRAW GRAFISCHE MOGELIJKHEDEN (3): DRAW

Een figuur tekenen met alleen maar LINE is erg omslachtig. Je kunt dan beter
het veelzijdige commando DRAW gebruiken. Achter DRAW komt een string te staan.
Dit kan zijn in de vorm van DRAW " .... " of DRAW A$. Beide manieren staan
als voorbeeld in programma 19.1. Tip bij het intypen: Typ n keer "GOSUB
wacht" in, sla het op in het geheugen met <Ctrl><Ins> en zet het iedere keer
op het scherm met <Shift><Ins>.

19.1. De mogelij 19.1. De mogelij 19.1. De mogelij 19.1. De mogelijkheden van DRAW kheden van DRAW kheden van DRAW kheden van DRAW
SCREEN 12
CLS
PSET (320, 100): GOSUB wacht 'zet punt op 320, 100
DRAW "u14": GOSUB wacht 'teken 14 pixels omhoog
DRAW "l16": GOSUB wacht 'teken 16 pixels naar links
DRAW "d20": GOSUB wacht 'teken 20 pixels omlaag
DRAW "r40": GOSUB wacht 'teken 40 pixels naar rechts
DRAW "e25": GOSUB wacht 'teken ze diagonaal (up, right)
DRAW "f30": GOSUB wacht ' idem (down, right)
DRAW "g50": GOSUB wacht ' idem (down, left)
DRAW "hl5": GOSUB wacht ' idem (up, left)
DRAW "m160,120": GOSUB wacht 'teken lijn naar punt 160,120
DRAW "bu70": GOSUB wacht 'ga 70 pixels omhoog (teken NIET)
DRAW "m-20,40": GOSUB wacht 'ga 20 naar links en 40 omlaag
DRAW "ne75": GOSUB wacht '75 diagonaal en keer terug
DRAW "nm500,150": GOSUB wacht 'naar punt 500,150 en keer terug
DRAW "l20": GOSUB wacht '20 naar links
CLS
PSET (320, 100): GOSUB wacht
DRAW "a1l": GOSUB wacht 'draai vanaf nu alles 90
DRAW "u14": GOSUB wacht '14 omhoog?? Nee dus, gedraaid!
DRAW "e40": GOSUB wacht 'diagonaal ook gedraaid.
PSET (50, 50): GOSUB wacht 'zet punt op 50,50
DRAW "ta34u14": GOSUB wacht '14 omhoog en draai dit 34
DRAW "ta-58u30": GOSUB wacht '30 omhoog en draai dit -58
PSET (500, 120): GOSUB wacht 'zet punt op 500,150
DRAW "a0" 'zet de draaiing uit
m$ = "u50 l50 d50 r50 h50 e25 f25 g50"
DRAW m$ 'gebruik een string
END

wacht:
RETURN

Uit dit programma zou duidelijk moeten zijn welke mogelijkheden je met DRAW
hebt. Zo niet, maak dan een eigen programma, waarin je zelf een aantal
mogelijkheden onderzoekt. Of gebruik de help van QuickBASIC (met voor-
beelden). Alle letters mogen overigens ook in hoofdletters worden gegeven.
Bij het instellen van de hoek ("A") heb je de mogelijkheden "A0" t/m "A3",
waarbij je iedere keer 90 verder draait.
Bij "TA" kun je zelf de hoek instellen, maar die moet liggen tussen -360
en +360.
Kleuren instellen kan met "C".

49

HET DRAAIENDE VIERKANT.
Je kunt met het variren van de hoek en de kleuren een voorwerp laten draaien.
De hoek laat je steeds lopen van 0 tot 360 en het voorwerp teken je en wis
je om en om (wissen met C0 = zwart). Het onderstaande programma is hier een
voorbeeld van.

19.2 Een voorwerp laten roteren 19.2 Een voorwerp laten roteren 19.2 Een voorwerp laten roteren 19.2 Een voorwerp laten roteren
SCREEN 12
CLS
V$ = "R80 D40 L80 U40" 'string voor een vierkant
A = 0 'beginhoek instellen op 0
LOCATE 24, 25
PRINT "Druk op een toets om te stoppen.";
DO
PSET (320, 80) 'beginpunt op 320, 80
DRAW "C7 TA" + STR$(A) + V$ 'teken rechthoek (C7 = wit)
DRAW "C0 TA" + STR$(A) + V$ 'wis rechthoek (C0 = zwart)
A = (A + 10) MOD 360 'hoek wordt 10 graden meer
LOOP WHILE INKEY$ = "" 'wacht op invoer
END

Het meest interessant in dit programma zijn de DRAW-opdracht en het variren
van de hoek. Eerst iets over die hoek. Een hoek steeds 10 graden groter laten
worden kan met A = A + 10. Maar A mag niet meer zijn dan 360.
Dus zou je kunnen toevoegen: IF A = 360 THEN A = 0, maar veel eleganter is:
A = (A + 10) MOD 360. A = de rest (als geheel getal) die overblijft als je
A + 10 deelt door 360. In een overzichtje staat hoe A verandert:

Oude waarde Berekening: Resultaat
van A: (= nieuwe waarde van A):

0 (0+10)\360=0 rest = A = 10 - 0 = 10
10 (10+10)\360=0 rest = A = 20 - 0 = 20
20 (20+10)\360=0 rest = A = 30 - 0 = 30
350 (350+10)\360=1 rest = A = 360 360 = 0

Onthoud deze truc!

Dan nog iets over de DRAW-opdracht. Van de hoek wordt een string gemaakt in
de opdracht STR$(A). Deze string wordt samen met V$ opgeteld bij de andere
string, zodat er zoiets staat als (stel A = 10):
DRAW "C7 TA10 R80 D40 L80 U40"
en dat is precies wat de bedoeling was.

50

HOOFDSTUK 20 HOOFDSTUK 20 HOOFDSTUK 20 HOOFDSTUK 20 GRAFISCHE MOGELIJKHEDEN (4): CIRKELS EN ELLIPSEN GRAFISCHE MOGELIJKHEDEN (4): CIRKELS EN ELLIPSEN GRAFISCHE MOGELIJKHEDEN (4): CIRKELS EN ELLIPSEN GRAFISCHE MOGELIJKHEDEN (4): CIRKELS EN ELLIPSEN

DE VICIEUZE CIRKEL.
Het is zeer eenvoudig om de computer een cirkel te laten tekenen. Typ hiervoor
het volgende programma in:

20.1 Cirkels tekenen 20.1 Cirkels tekenen 20.1 Cirkels tekenen 20.1 Cirkels tekenen
SCREEN 12
CLS
CIRCLE (320, 100), 50
CIRCLE (100, 50), 8
END

Het zal duidelijk zijn dat je na CIRCLE tussen haakjes de cordinaten van het
middelpunt aangeeft en daar achter de straal (in pixels). Probeer zelf maar
eens wat andere cirkels te maken.

Met een FOR...NEXTlus kun je weer leuke effecten creren.

20.2 Cirkels in een FOR...NEXT 20.2 Cirkels in een FOR...NEXT 20.2 Cirkels in een FOR...NEXT 20.2 Cirkels in een FOR...NEXT- -- -lus lus lus lus
SCREEN 12
CLS
FOR R = 0 TO 200 STEP 5
CIRCLE (320, 100), R
NEXT R
END

Waartoe dient de WHILE...WEND-opdracht?
Verander de CIRCLE-opdracht in: CIRCLE (200 + R, 100), R en start opnieuw.
Verander de CIRCLEopdracht in: CIRCLE (3 * R, R), R en start opnieuw.

20.3 Cirkels rondom het midden van het scherm 20.3 Cirkels rondom het midden van het scherm 20.3 Cirkels rondom het midden van het scherm 20.3 Cirkels rondom het midden van het scherm
SCREEN 12
CLS
pi = ATN(1) * 4
FOR R = 5 TO 360 STEP 5
H = pi * R / 180
X = 300 - INT(150 * COS(H))
Y = 100 - INT(50 * SIN(H))
CIRCLE (X, Y), 50
NEXT R
END

Verander de CIRCLE-opdracht in: CIRCLE (X, Y), R / 5

ER IS ER EEN JARIG ...
Een taart is meestal rond. Als je een stuk taart neemt, is dat stuk een deel
van een cirkel: een segment. Dergelijke taartstukken kun je ook door de PC
laten tekenen.

51

20.4 Cirkelsegmenten 20.4 Cirkelsegmenten 20.4 Cirkelsegmenten 20.4 Cirkelsegmenten
SCREEN 12
pi = ATN(1) * 4
CLS
CIRCLE (100, 25), 50, 2, 0, pi / 2
CIRCLE (400, 25), 50, 3, -.01, -pi / 2
CIRCLE (100, 50), 75, 4, pi, 2 * pi
CIRCLE (400, 50), 75, 5, -pi, -2 * pi
CIRCLE (100, 120), 100, 6, 4 / 3 * pi, 5 / 3 * pi
CIRCLE (400, 120), 100, 7, -4 / 3 * pi, -5 / 3 * pi
END

De volledige CIRCLE-opdracht ziet er als volgt uit:
CIRCLE (X, Y), straal, kleur, beginhoek, eindhoek, assenquotint
Hierin is X de x-cordinaat en Y de y-cordinaat.

De laatste twee waarden in de CIRCLE-opdracht van programma 20.4 betreffen
de begin- en de eindhoek van de cirkel. Deze hoek moeten worden weergeven in
radialen. Hierbij geldt: 180 radialen. Als deze waarden negatief zijn,
wordt ook een lijnstuk naar het midden van de cirkel getrokken. Let op dat
dit niet mogelijk is met 0 radialen. Vandaar dat in de tweede CIRCLE-opdracht
-.01 gebruikt is. Experimenteer zelf met andere waarden.

Met de laatste optie, het assenquotint, geef je de verhouding van de x- en
y-straal aan. Eenvoudiger gezegd: door hier een bepaalde waarde in te vullen,
krijg je een ellips. Zie programma 20.5.

20.5 Ellipsen 20.5 Ellipsen 20.5 Ellipsen 20.5 Ellipsen
SCREEN 12
CLS
FOR i = 0 TO 4
CIRCLE (50 + i * 120, 50), 50, 2, , , 1 / (i + 1)
CIRCLE (50 + i * 120, 150), 30, 14, , , (i + 1) / 5
NEXT i
END

Blijft er op n regel een bepaalde lengte (x of y) constant?
Experimenteer met andere verhoudingen. Leg uit waarom de verhouding 1 GEEN
cirkel oplevert.
Zoek uit welke verhouding je moet gebruiken om een cirkel te krijgen.
Experimenteer ook met segmenten van ellipsen (zie 20.4).

52

HOOFDSTUK 21 HOOFDSTUK 21 HOOFDSTUK 21 HOOFDSTUK 21 ZELF PROGRAMMA'S MAKEN (3) ZELF PROGRAMMA'S MAKEN (3) ZELF PROGRAMMA'S MAKEN (3) ZELF PROGRAMMA'S MAKEN (3)

1 Maak een programma waarmee je tegen iemand anders Boter, Kaas en Eieren
kunt spelen. Geef de negen vakjes een nummer, zodat je door het invoeren
van een cijfer kunt aangeven welk vakje je kiest. De PC moet zelf kunnen
bepalen of een kruisje of een rondje getekend moet worden. Probeer ook
of de PC het einde van het spel kan vaststellen.

Nu volgen wat moeilijke opdrachten. Als je hier zonder al te veel moeite uit
komt, kun je je met recht een gevorderd programmeur noemen!

2 Schrijf een programma dat het scherm in vakjes verdeelt met links en
beneden de cordinaten. Door de x- en y-cordinaat in te voeren moet het
betreffende vakje wit gekleurd worden. Nogmaals invoeren van deze
cordinaten moet het vakje weer zwart maken. Op deze manier kun je een
bepaald patroon maken. Bepaal zelf in hoeveel vakjes je het scherm wilt
verdelen. Gebruik indien nodig de WINDOW-opdracht.

3 Pas het programma van opdracht 2 aan, zodat je met de cursortoetsen over
de vakjes kunt "lopen". Afwisselend drukken op de spatiebalk moet het
vakje wit en zwart kleuren.

4 Maak een tekenprogramma. Met de besturingstoetsen (op het numerieke
toetsenbord) moet je lijnen kunnen trekken (gebruik DRAW). Probleem
hierbij is hoe het 'potlood' over het scherm te verplaatsen, zonder dat
er een lijn getrokken wordt? Een onelegante manier is toch een lijn te
tekenen, maar dan in het zwart. Dit is niet erg netjes, want gedeeltes
van reeds getekende lijnen kunnen dan worden gewist. Het volgende
probleem is dan direct: hoe weet je waar je bent op het scherm als je
geen lijn trekt? Je zou onderin beeld de cordinaten van het punt waar
je bent kunnen weergeven. Dit is niet erg praktisch, maar voorlopig de
enige oplossing.

5 Verander het programma van opdracht 4, zodat je nu ook cirkels en
rechthoeken (al dan niet gevuld) kunt tekenen. Bijvoorbeeld dat je op
C moet drukken voor een cirkel waarna je dan middelpunt en straal kun
opgeven. Bij een rechthoek geef je bijvoorbeeld de cordinaten van de
linker bovenhoek en de rechter benedenhoek. Gebruik B voor een gewone
rechthoek (Block) en F voor een gevulde rechthoek (Fill).

6 Schrijf een programma waarmee je een kleine cirkel over het scherm laat
bewegen zoals een biljartbal over een biljarttafel beweegt. Gebruik dus
de randen van het scherm als stootband. Laat de hoek van terugkaatsing
iets groter of kleiner zijn dan van de hoek van inval. Los hierbij de
volgende problemen op: de juiste richting bepalen na het raken van een
rand; zorgen dat de cirkel niet van het scherm afloopt.

Cursus Programmeren in QuickBasic 4.5

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Cursus Programmeren in QuickBasic 4.5

Uploaded by

Copyright:

Available Formats

C U R S U S C U R S U S C U R S U S C U R S U S

You might also like