Informaticasite van het Lauwers College te Buitenpost                 © R.J. van der Beek
 

Hoofdstuk 6 Programmeren in Pascal

6.1 Pascal, de start



  6.1.1 Het eerste programma

Pascal is een programmertaal, die is ontwikkeld door N. Wirth
Er zijn verschillende versies, dat worden Pascal-dialecten genoemd. Wij werken met Irie Pascal en dat is gebaseerd op Turbo-Pascal.
Turbo-Pascal heeft veel meer mogelijkheden dan standaard Pascal; je kunt er alleen MSDOS-programma's mee ontwikkelen, maar om te leren programmeren is het nog prima bruikbaar.
Delphi is een programmeertaal, waarmee je windows-programma's kunt maken, en dat gebaseerd is op Pascal.

Wij gaan dus werken met een Irie Pascal, dat is een Pascalversie voor Windows, en die kun je hier downloaden..
Er is ook een speciale site van Irie-Pascal, die heet http://www.irietools.com

Irie-Pascal is een zogenaamde IDE (= Integrated Development Environment), dat wil zeggen dat je m.b.v. Irie-Pascal je eigengemaakte programma in kunt tikken, en het meteen ook uit kunt laten voeren.

In Irie-Pascal moet je het volgende doen als je een programma wilt maken en laten lopen:
  • Klik in het menu eerst op Project, en dan op New
    Dan verschijnt er een venster waarin je een map kunt uitkiezen, waarin het project (en daarvan is het programma een onderdeel) moet worden opgeslagen.
    Verder moet je een naam invoeren, waaronder het project bewaard wordt.
    Als je als naam opg1 invoert en op OK klikt, dan wordt het project opgeslagen onder de naam opg1.ipj.



  • En dan verschijnt er een nieuw venster, waarin je het programma kunt invoeren. Het onderdeel waar je dan mee bezig bent heet de editor, daarmee kun je het programma intikken
  • Dan moet je het programma beslist eerst opslaan m.b.v. File → Save as
    Als je het de naam OPG1 geeft, dan wordt het als een tekstbestand met de naam OPG1.PAS opgeslagen.
  • Het programma compileren: Klik op Project → Compile
    Er wordt dan eerst gecontroleerd of er ook fouten in het programma zitten, als die er zijn wordt er aangegeven waar die fouten zitten, en dan moet je die eerst verbeteren.
    Als er geen fouten (meer) in zitten dan wordt het in "macinetaal" vertaald, en als je het getypte programma de naam OPG1 hebt gegeven, dan wordt het machinetaal-programma nu onder de naam OPG1.IVM opgeslagen.
    Dit is het uitvoerbare programma, het is geen tekstbestand. (De extensie .ivm staat voor Irie Virtual Machine executable)
  • Het programma runnen: Klik op Project → Run
    Het programma wordt nu in een DOS-box uitgevoerd, en je kunt zien of het werkt.
    (Eventueel kun je de vorige stap, het compileren, ook overslaan, want als je het programma runt wordt het automatisch eerst gecompileerd)
  • Als het programma in een DOS-box is uitgevoerd staat er altijd als laatste regel: Press Enter to continue ...
    As je dan op enter drukt verdwijnt het DOS-venster, en dan kun je terug naar de editor.

We gaan nu bekijken hoe een programma er uit ziet.

Kies voor een nieuw project (geef het de naam opg1), typ het volgende programma in, sla het op (weer onder de naam opg1), en laat het lopen (Project → Run), en lees het verhaal er onder door.



PROGRAM eersteprogramma;                                  
VAR g1,g2,s,v,p:INTEGER;                           
    q:REAL;                                        
BEGIN                                              
    WRITE('Typ een geheel getal in:');
    READLN(g1);      
    WRITE('Typ nog een getal in:');
    READLN(g2);         
    s:=g1+g2;
    writeln('De som is ',s);                  
    v:=g1-g2;
    writeln('Het verschil is ',v);            
    p:=g1*g2;
    writeln('Het produkt is ',p);            
    q:=g1/g2;
    writeln('Het quotient is ',q); 
END.

Wat betekent dit allemaal:
Een programma begint altijd met het woordje PROGRAM, met de naam van het programma er achter.
(Vrijwel) elke regel wordt afgeslopen met een puntkomma, ook de eerste regel met de naam.
Die eerste regel heet de "programma-heading".

Alle variabelen, die in het programma worden gebruikt, moeten worden "gedeclareerd".
Dat gebeurt in het declaratie-gedeelte, dat begint met VAR
Daar staat welke variabelen er worden gebruikt, en van welke soort (type) ze zijn.
INTEGER betekent : geheel getal
en REAL betekent : kommagetal.

Na het declaratie-gedeelte komt het hoofdprogramma. Dat begint met BEGIN en het eindigt met END.
Dit gedeelte wordt ook wel de romp of de body genoemd. Achter de laatste END staat een punt.
Dat is verplicht !

Opdrachten moeten worden gescheiden door punt-komma's. Meestal wordt er daarom direkt achter elke opdracht een punt-komma gezet. Er mogen wel meerdere opdrachten op één regel.

write('Typ een geheel getal in:');
Dit is een "uitvoer-opdracht".
Deze opdracht heeft tot gevolg dat, als het programma loopt, de zin tussen aanhalingstekens op het scherm verschijnt.

readln(g1);
Dit is een "invoer-opdracht".
Deze opdracht heeft tot gevolg dat de computer, als het programma loopt, net zo lang wacht tot er een getal is ingetypt (afgesloten met enter), en dat getal wordt dan "toegekend aan de variabele g1".

Elke variabele correspondeert met een plaatsje in het geheugen.
Je kunt het geheugen als een ladenkast beschouwen. Een variabele is dan een lade. De naam van de variabele (hier g1) staat op het etiket van de lade geschreven, en het ingetypte getal wordt in de lade gelegd.



s:=g1+g2; (spreek uit als: s wordt g1 plus g2 )
Dit is een "verwerkings-opdracht".
Deze opdracht heeft tot gevolg dat de computer, als het programma loopt, berekent wat er na het := teken staat. Dus de waarden van g1 en van g2 worden opgeteld. En die waarde wordt toegekend aan een nieuwe variabele s.
(Er wordt een nieuwe la gebruikt. Er verschijnt een s op het etiket van de la, en de uitkomst van de optelling wordt in de la gelegd.)

writeln( 'De som is ' , s )
Deze opdracht heeft tot gevolg dat de tekst  -De som is-  letterlijk wordt afgedrukt, en vlak daar achteraan wordt de waarde van s afgedrukt.

Wat tussen aanhalingstekens staat wordt dus letterlijk afgedrukt.
Als het niet tussen aanhalingstekens staat wordt er aangenomen dat het een variabele is waarvan de waarde moet worden afgedrukt.

In één WRITELN-opdracht kunnen meerdere schrijfopdrachten staan. Die moeten worden gescheiden door een komma. Om het geheel moeten haakjes.

Speciale Pascal-woorden worden vaak met hoofdletters getypt. Maar dat hoeft niet.
Het maakt niet uit of je iets met hoofdletters of met kleine letters typt.

Fouten

Als je een typfout gemaakt hebt, en het is een zogenaamde syntaxfout, dan geeft de computer dat aan als je het programma laat compileren of runnen.
Als je bijvoorbeeld een puntkomma vergeet aan het aande van een regel, dan wordt er gemeld:
; expected
En de plaats van de fout wordt ook aangegeven, met een regelnummer en kolomnummer.
In de figuur hier onder zie je dat er wordt aangegeven (8,5). Dat betekent: regel 8, kolom 5
Maar je moet er wel om denken dat de fout dan meestal in de vorige regel zit, de puntkomma is aan het eind van regel 7 vergeten. Maar die puntkomma zou ook aan het begin van regel 8 mogen staan!
Verder moet je er om denken dat het venster met de foutmeldingen voor het editor-venster zit, je moet het compilervenster even verkleinen om terug te kunnen keren naar het editor-venster.



Typen variabelen

Er zijn meer typen variabelen, voorlopig hebben we genoeg aan de volgende vijf:

type         betekenis                      
INTEGERgeheel getal tussen circa -32000 en 32000
REALkommagetal
LONGINTgeheel getal dat veel groter kan zijn dan een INTEGER
STRINGwoord
BOOLEANkan alleen waar of onwaar (true of false) zijn, daarover later
WORDgeheel getal tussen 0 en circa 64000


Opgaven.
Maak nu opgave 1, 2 en 3 van hoofdstuk 6 (Pascal)

  6.1.2 De keuzestructuur m.b.v. IF ... THEN ...

In Pascal kun je een zogenaamde als-dan opdracht uit laten voeren.
Die opdracht wordt dan alleen uitgevoerd als er aan een bepaalde voorwaarde is voldaan.
En anders wordt de opdracht overgeslagen, en wordt er verdergegaan met de volgende opdracht.

Tik het volgende programma over, en laat het een aantal keer lopen.

PROGRAM som;
VAR a, b, s : INTEGER;

BEGIN
    CLRSCR;
    RANDOMIZE;
    a:=RANDOM(50);
    b:=RANDOM(50); 
    WRITE(a,'+',b,'=');                             
    READLN(s);                                                  
    IF (s=a+b) THEN WRITE('   Goed zo !') ELSE WRITE('   Fout');  
END.

Uitleg:

CLRSCR :
Dat is de opdracht om het scherm schoon te maken (spreek uit als clear screen)

a:=RANDOM(50);
Deze opdracht heeft tot gevolg dat a een willekeurige (gehele) waarde onder de 50 krijgt.
Dus dat kan 0, 1, 2, ... , 49 zijn. Die waarde hangt van het toeval af.

RANDOMIZE;
Deze opdracht heeft tot gevolg dat je niet elke keer als het programma loopt de zelfde "willekeurige getallen" krijgt.

IF (  ...  ) THEN   ...   ELSE  ...
betekent     Als (  ...  ) geldt dan moet   ...   gebeuren en anders   ...
(ELSE .... mag je ook weglaten)
N.B. De voorwaarde achter IF moet tussen haakjes worden geplaatst !

Samengestelde voorwaarde

Soms moet je een aantal dingen tegelijk controleren.
Bekijk het volgende programma maar eens. 

PROGRAM hoe_oud;
VAR leeftijd: REAL;

BEGIN
   CLRSCR;
   WRITE('Hoe oud ben je ');
   READLN(leeftijd);
   IF (leeftijd > 19) THEN writeln ('Oude zak !');
   IF (leeftijd < 11) THEN writeln ('Kleutertje !');
   IF (leeftijd > 10) and (leeftijd < 20) THEN writeln ('Puber !');
END.

Uitleg:
De opdracht IF (leeftijd > 10) and (leeftijd < 20) THEN writeln ('Puber !');
heeft tot gevolg dat, als de leeftijd tussen 10 en 20 jaar is, er wordt gezegd dat je een puber bent.
Je kunt dus het woordje and tussen de voorwaarden zetten.
Ook het woordje or kan er tussen, en dat betekent natuurlijk of.
Er staat in je theorieboek op blz. 234 onderaan een programma waarmee het kleinste van vier getallen kan worden bepaald.
Dat programma ziet er als volgt uit:

PROGRAM minimum;
VAR g1, g2, g3, g4, kleinste: REAL;

BEGIN
   CLRSCR;
   WRITE('Geef getal 1: ');
   READLN(g1);
   WRITE('Geef getal 2: ');
   READLN(g2);
   WRITE('Geef getal 3: ');
   READLN(g3);
   WRITE('Geef getal 4: ');
   READLN(g4);
   IF g1 < g2 THEN kleinste:=g1 ELSE kleinste:=g2;
   IF g3 < kleinste THEN kleinste:=g3;
   IF g4 < kleinste THEN kleinste:=g4;
   WRITE('Het kleinste is: ');
   WRITE(kleinste);
END.

Probeer dit programma maar eens uit.
Telkens wordt er om vier getallen gevraagd. En daarna wordt afgedrukt wat het kleinste van die vier getallen was.

Uitleg:
De eerste acht opdrachten na BEGIN zijn om de vier getallen op te vragen.
De variabele kleinste is een hulpvariabele, waarin het kleinste getal moet worden bewaard.
Nadat de opdracht
       IF g1 < g2 THEN kleinste:=g1 ELSE kleinste:=g2;
is uitgevoerd zit er in de variabele kleinste het minimum van g1 en g2
Nadat de opdracht
       IF g3 < kleinste THEN kleinste:=g3;
is uitgevoerd zit er in de variabele kleinste het minimum van g1 en g2 en g3
En nadat de opdracht
       IF g4 < kleinste THEN kleinste:=g4;
is uitgevoerd zit er in de variabele kleinste het minimum van g1 en g2 en g3 en g4
En daarna wordt die waarde nog afgedrukt.

Dit programma kun je gemakkelijk uitbreiden voor meer getallen.
Maar dan kun je handiger gebruik maken van de herhalings-opdracht.

Opgaven.
Maak nu opgave 4 t/m 7 van hoofdstuk 6 (Pascal)

  6.1.3 Herhalingsstructuur m.b.v. FOR ... DO ...

De grote kracht van programma's is dat er heel snel iets herhaald kan worden.
In Pascal kan dat m.b.v. de FOR-DO-opdracht, hieronder lees je hoe je dat doet.

Tik het volgende programma over, en laat het lopen.
Lees ook de uitleg er onder door.

PROGRAM herhaling;                                      
 VAR i:integer;                                           
 BEGIN                                                    
     CLRSCR;                                                  
     FOR I:=1 TO 10 DO WRITELN('Piet de Boer (tik je eigen naam in)'); 
 END.

Uitleg:

FOR i := 1 TO 10 DO ..................
Als je deze opdracht geeft dan wordt de opdracht op de stippeltjes 10 keer uitgevoerd.
Alleen de eerste opdracht na het woordje DO, tot aan de eerste punt-komma !!!
Daarom moet je nooit een punt-komma zetten vlak achter het woordje DO.

Je kunt een zogenaamde for-lus ook gebruiken om dingen te herhalen, die niet precies gelijk zijn, maar waar de teller-variabele in voorkomt.
Tik het volgende programma in, en laat het lopen. Lees ook de uitleg er onder door. 

PROGRAM wacht;                                      
 VAR i:integer;                                           
 BEGIN                                                    
     CLRSCR;                                                  
     FOR I:=1 TO 10 DO 
     BEGIN
        WRITELN(i , 'x 13 =' , i*13); 
        DELAY(1000);
     END;
 END.

Uitleg:

DELAY(1000) :
Als de computer deze opdracht tegenkomt dan wacht hij 1000 milliseconden (dus 1 sec).

Samengestelde opdracht.
Als je de opdracht FOR i := 1 TO 10 DO .................. geeft dan wordt de opdracht op de stippeltjes 10 keer uitgevoerd.
Maar alleen de eerste opdracht na het woordje DO !!!
Wil je dat een groepje opdrachten wordt herhaald, dan moet je er voor zorgen dat dat groepje opdrachten als één samengestelde opdracht wordt opgevat.
En dat doe je door dat groepje opdrachten tussen de woorden BEGIN en END te zetten.
Dus de opdrachten WRITELN(i , 'x 13 =' , i*13); en DELAY(1000); worden tien keer herhaald.
Dat betekent dat er de eerste keer 1 x 13 = 13 op het scherm verschijnt, en dat er dan een seconde gewacht wordt.
( WRITELN(i , 'x 13 =' , i*13); betekent dat eerst de waarde van i wordt afgedrukt, dan wordt x 13 = precies zo afgedrukt, en daarna wordt i*13 berekend en afgedrukt. Dat laatste staat niet tussen aanhalingstekens dus wordt de waarde van i*13 afgedrukt)
De tweede keer verschijnt er 2 x 13 = 26 en er wordt een seconde gewacht.
De derde keer verschijnt er 3 x 13 = 39 en er wordt een seconde gewacht.

En zo gaat dat door tot en met 10

Als je de opdracht    FOR i := 10 DOWNTO 1 DO ..................
geeft dan wordt de opdracht op de stippeltjes ook 10 keer uitgevoerd, maar i doorloopt dan de waarden van 10 tot en met 1, dus in omgekeerde volgorde.

Herhaalde optelling
We gaan een programma maken dat de uitkomst van het volgende berekent:
7 + 8 + 9 + 10 + . . . + 23
Tik het over en probeer het uit.

PROGRAM optelling;
VAR som, i : INTEGER;
BEGIN
   CLRSCR;
   som:=0;
   FOR i:=7 TO 23 DO
   BEGIN
       som:=som+i;
   END;
   WRITELN('De som van de getallen is ' , som);
END.

Uitleg:

Als je zelf zo'n grote optelling (zonder rekenmachine) moet maken, dan tel je niet al die getallen tegelijk op.
Je telt de eerste twee op, bij die uitkomst tel je het derde getal op, enz.
Je onthoudt steeds het tussenresultaat, dat is de voorlopige som.
Die voorlopige som wordt in de variabele som vastgelegd.
som := 0 wordt de initialisatie genoemd , de waarde van som in het begin is 0.

som := som+i;
De eerste keer heeft i de waarde 7, en som de waarde 0, dus dan wordt de nieuwe waarde van som 7
De tweede keer heeft i de waarde 8, en som de waarde 7, dus dan wordt de nieuwe waarde van som 15
De derde keer heeft i de waarde 9, en som de waarde 15, dus dan wordt de nieuwe waarde van som 24
en zo gaat dat verder, tot en met 23

Uiteindelijk bevat de variabele som de waarde die we willen hebben.
Je moet er dan nog wel voor zorgen dat die waarde op het scherm verschijnt.
Daar dient de opdracht WRITELN('De som van de getallen is ' , som); voor.


Opgaven.
Maak nu opgave 8 t/m 11 van hoofdstuk 6 (Pascal)

  6.1.4. Herhalingsstructuur m.b.v. WHILE ... DO ...

Het komt vaak voor dat er iets herhaald wordt, maar dat in het begin nog niet duidelijk is hoevaak het herhaald moet worden.
Dan gebruik je in Pascal vaak de WHILE-DO-opdracht of de REPEAT-UNTIL-opdracht.

In het volgende programma wordt er steeds gevraagd om een getal in te vullen.
Maar er staat bij dat als je wilt stoppen moet je een 0 intikken.
En dan wordt daarna afgedrukt hoeveel getallen je hebt ingevoerd, en wat het gemiddelde van die getallen was.

Tik het programma in, en laat het lopen. Lees de uitleg eronder door. 

PROGRAM opg_met_while;                                          
VAR getal,som:REAL;
    aantal:INTEGER;                          
BEGIN                                                        
   CLRSCR;
   som:=0;
   aantal:=0;
   getal:=1;                       
   WHILE (getal<>0)  DO                                          
   BEGIN                                                      
       WRITE('Geef een positief getal (0=stoppen) ');
       READLN(getal);                 
       aantal:=aantal+1;
       som:=som+getal;                         
   END;                                                       
   WRITELN;
   aantal:=aantal-1;  
   WRITELN('Het aantal getallen is ',aantal);                                                  
   WRITELN('Het gemiddelde is ',som/aantal);                  
END.

Uitleg:

Bij WHILE ( . . . . . .  ) DO    - - - - - - - -
wordt de opdracht op    - - - - - - - -    net zo lang uitgevoerd als (   . . . . . .   ) geldt.

Je zou het zo kunnen vertalen: Zolang (    . . . . . .    ) doe    - - - - - - - -
De voorwaarde op . . . . . . wordt het stopcriterium genoemd.
  • In bovenstaand programma zie je de opdracht:
    WHILE (getal<>0) DO .......

    De opdrachten daarna (tussen BEGIN en END) worden herhaald zolang getal<>0 is.
    (getal<>0 betekent: de waarde van de variabele getal is niet gelijk aan 0)

  • Voor de WHILE-opdracht staat o.a. de opdracht getal:=1. Die opdracht staat er om er voor te zorgen dat de opdracht na WHILE tenminste één keer wordt uitgevoerd. Anders zou het toevallig kunnen zijn dat getal de waarde 0 had in het begin, en dan werd die opdracht helemaal niet uitgevoerd.)

  • som:=0; aantal:=0; getal:=1;
    deze opdrachten vormen de initialisatie, de variabelen krijgen beginwaarden.

  • READLN(getal);
    heeft tot gevolg dat de computer wacht tot er een getal is ingetypt, en dat getal wordt dan toegekend aan de variabele getal.

  • aantal:=aantal+1;
    heeft tot gevolg dat aantal met één wordt vermeerderd.

  • som:=som+getal;
    heeft tot gevolg dat de ingetypte waarde bij de waarde van som wordt opgeteld. En dus bevat de variabele som aan het eind van het programma de optelling van alle ingetypte getallen.

  • Als er een 0 wordt ingetypt dan krijgt de variabele getal de waarde 0 en dan wordt er met de herhaling van de WHILE-DO-opdracht gestopt.

  • En dan wordt nog het aantal ingevoerde getallen afgedrukt (de opdracht aantal:=aantal-1; staat er nog bij omdat het aantal anders één te hoog is omdat er, toen de 0 werd ingetypt, ook nog 1 bij opgeteld is).
    En ook het gemiddelde van de getallen wordt afgedrukt: som bevat de som van alle getallen, aantal het aantal ingevoerde getallen; als je die twee op elkaar deelt krijg je het gemiddelde.
Opgaven.
Maak nu opgave 12 van hoofdstuk 6 (Pascal)

  6.1.5. Herhalingsstructuur m.b.v. REPEAT ... UNTIL ...

In plaats van de WHILE-DO-opdracht kun je ook de REPEAT-UNTIL-opdracht gebruiken.
Er zijn een paar verschillen:
  • Bij REPEAT-UNTIL wordt achteraf getest of aan de voorwaarde voldaan wordt om te herhalen.
    Dat heeft tot gevolg dat de opdracht in ieder geval één keer wordt uitgevoerd. Bij WHILE-DO kan dat nul keer zijn.
  • De voorwaarde bij WHILE-WEND is net andersom als bij REPEAT-UNTIL.
  • Bij REPEAT-UNTIL hoeven de opdrachten, die herhaald moeten worden, niet tussen BEGIN en END te staan. Bij WHILE-DO wel
  • Bij WHILE-DO wordt vooraf getest of aan de voorwaarde voldaan wordt om te herhalen. Dat heeft tot gevolg dat als in het begin niet aan de voorwaarde is voldaan, de opdracht geen enkele keer wordt uitgevoerd. Bij WHILE-DO kan dat nul keer zijn.

In het volgende programma moet er een getal tussen 10 en 25 worden geraden.
Er wordt steeds gevraagd om een getal tussen 10 en 25 in te voeren, net zolang tot het juiste getal wordt geraden (en dat is 21).
En dan wordt er gezegd in hoeveel beurten je het geraden hebt.

Er wordt dus net zolang doorgegaan tot het ingevoerde getal 21 is, en de opdracht daarvoor is:
REPEAT
..............
..............
UNTIL (getal=21);
Hier komt het programma. Tik het in, en laat het lopen. Probeer te begrijpen wat er gebeurt. 

PROGRAM opg_met_repeat;                                          
VAR getal,aantal:INTEGER;                          
BEGIN                                                        
   CLRSCR;
   aantal:=0;
   REPEAT                                          
       WRITE('Geef een getal tussen 10 en 25 ');
       READLN(getal);                 
       aantal:=aantal+1;
       IF (getal=21) THEN 
           WRITELN ('Goedzo. Geraden in ', aantal , ' beurten')
       ELSE
           WRITELN ('Fout, nog eens'); 
   UNTIL (getal=21);                        
END.

  6.1.6. Inspringen en puntkomma's

Inspringen
Je ziet dat bij het uittypen van de programma's er op bepaalde plaatsen is ingesprongen.
Na BEGIN wordt er steeds 4 kolommen ingesprongen, en voor END wordt er weer 4 posities terug gesprongen.
Daardoor wordt het overzichtelijker, en zie je beter wat er gebeurt.
Ook na REPEAT, en voor UNTIL.
En na IF - THEN

Het punt-komma reglement.
De puntkomma's tussen de opdrachten worden in het begin nogal eens vergeten.
Maar er worden ook wel eens puntkomma's geplaatst waar het niet nodig is, of waar het niet mag.

De regels voor het zetten van puntkomma's zijn als volgt:
  1. Na elke opdracht dient een puntkomma te worden geplaatst, wanneer daar weer een opdracht op volgt.
  2. Na een opdracht hoeft geen puntkomma te worden geplaatst, wanneer daar het woord END of het woord UNTIL op volgt.
  3. Voor het woord ELSE geen puntkomma plaatsen,
  4. Na het woordje DO geen puntkomma plaatsen.
  5. Achter de afsluitende END van een programma staat geen puntkomma, maar een punt.