In de vorige paragraaf hebben we een voorbeeld gezien van een procedure die een regel gecentreerd in een kader zet. Dit was al heel wat, maar het wordt interessanter wanneer we zouden kunnen aangeven welke regel we in een kader zouden willen zetten en met welk karakter we het kader willen maken. Dit kan door gebruik te maken van zogenaamde parameters (waarbij de klemtoon op de tweede lettergreep ligt).
Een parameter is eigenlijk een soort van variabele die we gerbuiken om gegevens tussen procedures (of functies) uit te wisselen, dan wel procedures (of functies) te voorzien van de juiste informatie.
Om de zaken niet al te simpel te houden gaan we kijken naar resp. het verschil tussen formele- en actuele-parameters en het verschil tussen var- en value-parameters.
Maar eerst gaan we kijken naar een simpel voorbeeld: maak een procedure die de som van twee getallen geeft.
program p8_1;
var getal1, getal2: integer;
procedure telop(a,b: integer);
begin
writeln(a,’+’,b,’=’,a+b);
end;
begin
write(‘Geef eerste getal: ‘);
readln(getal1);
write(‘Geef tweede getal: ‘);
readln(getal2);
telop(getal1, getal2);
end.
Wat gebeurt er nu precies? In de op één na laatste regel (van het hoofdprogramma) wordt de procedure telop aangeroepen. Tussen haken staan nu twee argumenten. Deze argumenten dienen qua aantal en qua type overeen te komen met de definitie van telop! Als aan beide is voldaan (in ons voorbeeld is dat zo, ga dat na!!!), dan vindt er ‘parameter-overdracht’ plaats. Dat wil in ons voorbeeld zeggen dat getal1 met a wordt gekoppeld en getal2 met b wordt gekoppeld. Tijdens de uitvoer krijgt a dus de waarde van getal1 en b de waarde van getal2.
Actuele- vs. formele parameters.
In het voorbeeld hierboven zijn getal1 en getal2 in de aanroep van som de actuele parameters (ze hebben daar een ‘echte’ waarde). De parameters a en b zijn formeel, omdat ze alleen voorkomen in de definitie van telop, en daar geen ‘echte’ waarde hebben.
Voor we verdergaan is het belangrijk bovenstaand concept goed te begrijpen!
Overigens heb ik om verwarring te voorkomen in het programma de namen van de variabelen en parameters verschillend gehouden. Dit is niet noodzakelijk!
In het volgende voorbeeld gaan we de procedure telop aanpassen en wel als volgt: Ik wil een derde parameter hebben waarin de waarde van de som van de eerste twee parameters komt.
program p8_2;
var getal1, getal2, som: integer;
procedure telop(a,b,s: integer);
begin
s := a + b;
end;
begin
write(‘Geef eerste getal: ‘);
readln(getal1);
write(‘Geef tweede getal: ‘);
readln(getal2);
telop(getal1, getal2, som);
writeln(getal1,’+’,getal2,’=’,som);
end.
Run het programma. Wat valt je op? Uit iedere optelling komt 0! Dat is natuurlijk niet goed en ook niet de bedoeling. Wat is hier aan de hand?
Var- en value-parameters.
De parameters die we tot op heden zijn tegengekomen, fungeerde voor de procedure als invoer. Dat noemen we value-parameters, ook wel invoer-parameters of val-parameters genoemd.
In de meeste gevallen zal dat ook de bedoeling zijn. Dat is de reden dat in Pascal een parameters standaard (default) als value-parameter wordt aangemerkt.
In ons laatste geval echter willen we dat de optelling van de parameters a en b als resultaat in s wordt gestopt en dat die waarde s wordt teruggegeven (geretourneerd) aan de aanroepende regel.
Om dit voor elkaar te krijgen moeten we van de parameter s een var-parameter maken.
In Pascal gaat dat d.m.v. het woordje var voor de parameter(s) te plaatsen.
De definiërende regel wordt nu:
procedure telop(a,b: integer; var s: integer);
De implementatie blijft verder hetzelfde.
Wanneer je nu het programma runt, zul je zien dat de waarde van de formele parameter s keurig wordt teruggegeven aan de actuele parameter som.
Type-declaratie.
Alvorens we naar de oefeningen gaan, moet je eerst weten dat je in Pascal ook zelf Types kan declareren.
Volgens de standaard van Pascal moet je dat voor de variabele-declaratie(s) doen.
In Pascal gaat dat als volgt:
Type [naam] = [soort-type];,
waarbij [naam] een unieke naam moet zijn, en [soort-type] aangeeft wat [naam] voor soort type is.
Je gebruikt deze constructie voor de zgn. gestructureerde types (waarover in een later hoofdstuk meer), voor opsombare types of (in Turbo Pascal) voor string-types.
Deze laatste zijn voor de volgende situatie van groot belang. Wanneer je een string-variabele declareert moet je tussen blokhaken aangeven hoe groot die string maximaal mag zijn. Wanneer je nu een parameter van het type string wilt hebben, dan vindt Pascal het niet goed dat je daarbij blokhaken gebruikt.
Dit mag dus niet: procedure wiv(s: string[60]);!
Voorbeeldjes:
Type
NulTotHonderd = 0..100;
Karakter = char;
s80 = String[80];
Het type NulTotHonderd accepteert getallen vanaf 0 t/m 100.
Het type Karakter is nu hetzelfde als het type char (redelijk onzinnig dus).
Het type s80 kan een string van maximaal 80 karakters bevatten.
Met het type s80 in de hand kan nu wel een parameter worden gedeclareerd. Goed is dus: procedure wiv(s: s80);!
Oefeningen.
8.1
Pas het programma p7_1.pas zo aan dat de ingevoerde regel als parameter aan de procedure kader wordt meegegeven. [Antwoord]
8.2
Pas het programma p7_1.pas zo aan dat de procedure kader een tweede parameter krijgt die aangeeft uit welk karakter het kader moet worden gebouwd. [Antwoord]
[Deelprogramma’s en variabelen(2)] <– –> [Functies]