|
Programma besturing
De WHILE lus
De programmeertaal C heeft verschillende structuren beschikbaar voor
iteraties en beslissingen. We zullen die in deze les gaan bestuderen,
te beginnen met de while lus. De while lus blijft verwerken zolang een
bepaalde conditie WAAR is. Zodra de conditie ONWAAR wordt, eindigt
de verwerking van de lus. While doet dus precies wat het statement
zegt, doe zolang. Bestudeer nu het programma WHILE.C.
<![CDATA[
main ()
{
int punten;
punten = 0;
while (punten < 60) {
printf ("Het totaal aantal punten is %d \n", punten);
punten = punten + 10;
}
}
]]>
We zien dat het programma begint met de declaratie van de integer
variabele punten binnen het hoofdblok. De variabele krijgt
de waarde nul. Dan komen we bij de while lus zelf.
De syntax van de while statement is zoals we hem hier zien.
Het gereserveerde woord while wordt gevolgd door een
voorwaarde tussen haakjes. Zolang nu de voorwaarde tussen haakjes waar
is, worden alle statements die tussen de accolades staan uitgevoerd.
In dit geval wordt de waarde van de variabele punten
opgehoogd tot en met 60 en stopt de verwerking. Het programma zal
verder gaan met het statement volgend op de while, in dit
geval einde programma.
Hetgeen tussen haakjes staat is de voorwaarde, de conditie, waarover
later meer. Neem voorlopig aan dat de conditie waar of niet waar
oplevert.
Enkele dingen moeten nog worden opgemerkt over de while lus. Ten
eerste, als de variabele punten bij aanvang van de lus reeds
de waarde 60 of hoger had, wordt geen enkel statement tussen de
accolades uitgevoerd. Het is dus mogelijk dat de statement van de while
lus nul keer worden verwerkt. Ten tweede, als de variabele
punten in het geheel niet wordt opgehoogd, krijgt men een
eindeloze lus. In zo'n geval zal het programma niet
eindigen. Ten slotte, als er maar een enkel statement in de lus staat,
mogen de accolades worden weggelaten.
Compileer en test dit programma nu.
De DO-WHILE lus
Een variatie op de while lus is de do-while lus, hetgeen bestudeerd kan
worden met programma DOWHILE.C.
<![CDATA[
main ()
{
int punten;
punten = 0;
do {
printf ("Het totaal aantal punten is %d \n", punten);
punten = punten + 10;
} while (punten < 60);
}
]]>
Dit programma is vrijwel gelijk aan het vorige programma. Het verschil
bestaat hieruit dat de do-while lus begint met het gereserveerde woord
do. De statements die herhaald moeten worden uitgevoerd
staan ook hier tussen accolades. Achter de sluit accolade staat de
voorwaarde voorafgegaan door het gereserveerde word while.
Ook hier de voorwaarde tussen haakjes.
De statements in de lus worden uitgevoerd totdat de conditie niet waar
wordt. Het programma wordt dan voortgezet met het statement volgend op
de do-while. Omdat voor de do-while geldt dat de test achteraf wordt
gedaan, zullen de statements binnen de lus altijd minstens een maal
worden uitgevoerd. Ten tweede, als de variabele punten nooit
wordt opgehoogd, zal de verwerking niet eindigen. Tenslotte geldt ook
hier dat accolades niet nodig zijn, als er maar een statement in de lus
staat.
Compileer en test het programma.
Opmerking: Het is uiteraard toegestaan om een lus
binnen een andere lus te programmeren (nesten).
De FOR lus
De for lus is niet iets nieuws, maar een andere manier om de while lus
te schrijven. De for gedraagt zich dus als de
while. Bestudeer nu het programma FORLOOP.C als voorbeeld
van een programma met daarin een for lus.
De for lus bestaat uit het gereserveerde woord for gevolgd
door een tamelijk uitgebreide expressie tussen haakjes.
De expressie is opgebouwd uit drie delen die worden gescheiden door
punt-komma's.
<![CDATA[
main ()
{
int index;
char worp[6][2];
for (index = 1; index < 6; index = index + 1) {
strcpy (worp[index], ".");
} /* endfor */
}
]]>
Het eerste deel bevat de expressie index = 1 en draagt zorg
voor de nodige initialisatie. Alle expressies die in dit deel
voorkomen, worden uitgevoerd voordat de statements van de eigenlijke
for lus zelf worden uitgevoerd. In principe mogen er heel veel
initialisatie stappen worden geprogrammeerd op deze plek, echter maak
er een gewoonte van dit deel eenvoudig en overzichtelijk te houden.
Indien er meerdere stappen worden geprogrammeerd dan moeten deze worden
gescheiden door een komma.
Het tweede deel, hier de expressie index < 6, is de test die
wordt uitgevoerd voordat aan de doorgang door de lus wordt begonnen.
Het mag elk soort expressie zijn die na evaluatie een WAAR of een
ONWAAR oplevert.
Het derde deel, hier de expressie index = index + 1, wordt
uitgevoerd telkens na een doorgang door de lus. Als de lus niet wordt
doorlopen, worden ook de statements van dit deel niet uitgevoerd. Er
mogen ook hier, net als in het eerste deel, meerdere statements staan,
die worden gescheiden door een komma.
De for() expressie wordt vervolgens gevolgd door een (1)
statement. Dit mag uiteraard een groep zijn. Dit statement of deze
groep statements wordt bij elke lus doorgang uitgevoerd. In de
programmeertaal C is het bijna altijd zo dat een enkel statement mag
worden vervangen door een groep statements omgeven door accolades.
Compileer en test dit programma nu.
Het IF statement
Bestudeer nu het programma IFELSE.C als voorbeeld van een programma met
een beslissing, de if. Het programma bevat twee
statements, een zonder en een met een else tak.
Laten we het eerste statement bekijken. Het begint met het
gereserveerde woord if gevolgd door een expressie tussen
haakjes. De expressie wordt ge‰valueerd. Wanneer deze WAAR is, wordt
het enkele statement op de volgende regel uitgevoerd. Indien de
expressie ONWAAR is, wordt dat statement overgeslagen.
Ook hier geldt weer dat het enkele statement mag wordt vervangen door
een groep, bestaande uit een of meerdere andere statements omgeven door
accolades.
<![CDATA[
main ()
{
int score = 100;
int persrec = 200;
if (score > persrec)
printf ("Je hebt je persoonlijk record verbeterd !!!\n", score);
if (score > persrec)
printf ("Score: *** %04d *** \n", score);
else
printf ("Score: %04d \n", score);
}
]]>
De expressie score > persrec vraagt eenvoudig af of de
waarde van de huidige score groter is dan die van het persoonlijk
record van de speler.
Het tweede if statement is vrijwel gelijk aan de eerste,
echter nu is het uitgebreid met het gereserveerde woord
else. Als na evaluatie de expressie WAAR is wordt de eerste
printf uitgevoerd. Als deze ONWAAR is wordt de tweede
printf uitgevoerd. Er wordt dus altijd iets
afgedrukt, terwijl in het eerste geval er soms wel en soms niet iets
wordt afgedrukt.
Beide vormen hebben zo hun eigen toepassing binnen een programma. Het
tweede if statement wordt hier toegepast om de score extra
te accentueren, wanneer deze boven het persoonlijk record uitkomt.
Compileer en test nu dit programma.
Het BREAK en CONTINUE statement
Bestudeer het programma BREAKCON.C als voorbeeld van het
break en continue statement. Het programma bevat
twee bijna identieke iteraties.
<![CDATA[
main ()
{
int xx;
for (xx = 5; xx < 15; xx = xx + 1) {
if (xx == 10)
break;
printf ("In het 'BREAK' deel; xx heeft de waarde %d\n", xx);
}
for (xx = 5; xx < 15; xx = xx + 1) {
if (xx == 10)
continue;
printf ("In het 'CONTINUE' deel; xx heeft de waarde %d\n", xx);
}
}
]]>
In de eerste iteratie staat een if die een break
aanroept als xx de waarde 10 bereikt. Het break
statement heeft als eigenschap uit de lus van een iteratie te springen
en het programma te vervolgen met het eerste statement na de
lus. De lus wordt daarmee (voortijdig) be‰indigd. Het is een waardevol
statement in die situaties waar je uit de lus van een iteratie wil
springen afhankelijk van de waarde van een bepaald resultaat dat in de
lus zelf wordt berekend.
De tweede iteratie bevat een continue statement. Dit
statement heeft als eigenschap uit de lus van een iteratie te springen,
maar de lus niet te be‰indigen. Het programma wordt vervolgd met het
eerste statement in de lus. Als xx de waarde 10
bereikt, zal het programma naar het begint van de lus springen en
doorgaan. Het effect zal zijn dat alle waarden worden afgedrukt,
behalve de waarde 10.
Compileer en test dit programma om te zien of het werkt zoals je denkt.
Het SWITCH statement
Bestudeer nu het programma SWITCH.C om een indruk te krijgen van een
van de sterkste structurerings primitiva van de programmeertaal C, de
switch. De switch is niet echt ingewikkeld, dus
laat je er niet door afschrikken.
Het statement begint met het gereserveerde woord switch
gevolgd door een variabele tussen haakjes. De waarde van deze
variabele, in het voorbeeld opdracht, bepaald naar welke tak
van de verwerking wordt gesprongen. Vervolgens worden een aantal takken
van verwerking opgenomen tussen accolades. Het gereserveerde woord
case gevolgd door een getal gevolgd door een dubbele punt
wordt gebruikt om zo'n tak aan te geven. De tak die zal worden
doorlopen, is degene waarvan het getal overeenkomt met de waarde van de
variabele.
<![CDATA[
main ()
{
int opdracht;
switch (opdracht) {
case 1:
printf ("Verwerk 'vooruit bladeren' opdracht ...\n");
break;
case 2:
printf ("Verwerk 'achteruit bladeren' opdracht ...\n");
break;
case 3:
case 4:
case 9:
printf ("Stop de verwerking.\n");
break;
default:
printf ("Dit is een onbekende opdracht !!!\n");
break;
}
}
]]>
Als in het voorbeeld programma opdracht de waarde 2 heeft,
zal de tekst Verwerk 'achteruit bladeren' opdracht ...
worden afgedrukt. De break zal er vervolgens voor zorgen dat
uit de switch wordt gesprongen.
Zodra een verwerkings-tak wordt gevonden, zullen de statements in die
tak worden uitgevoerd totdat een break wordt gevonden of
totdat het programma door de laatste tak valt. Dit laatste
is belangrijk om te onthouden.
Als opdracht de waarde 3 heeft, zullen de statements na
case 3: worden uitgevoerd. Hier echter staan de eerste
statements pas na case 9:. Het gevolg is dat de tekst
Stop de verwerking. wordt afgedrukt en het programma verder
gaat na de switch.
De verschillende takken mogen in elke willekeurige volgorde staan. Als
een tak niet wordt gevonden, wordt het deel achter
default: uitgevoerd. Als opdracht de waarde
16 heeft, zal de tekst Dit is een onbekende opdracht !!!
worden afgedrukt.
Tenslotte nog een opmerking. De hiervoor behandelde statements mogen
alle binnen elkaar genest worden of in elke volgorde na
elkaar geprogrammeerd worden.
Compileer en test dit programma.
Een voorbeeld programma
Bestudeer nu het programma PVK.C. Het programma lost het probleem op
van een boer die naar de markt gaat. Hij heeft honderd gulden en
daarvoor moet hij precies honderd beesten kopen. Een paard kost
vijftien gulden, een varken kost een gulden en de kippen kosten een
kwartje. De vraag is hoeveel paarden, varkens en kippen moet hij kopen.
Er is een (1) oplossing. Onderstaand het C programma.
<![CDATA[
main ()
{
int paard, varken, kip, beesten;
float bedrag, subtot;
printf ("PAARDEN VARKENS KIPPEN BEDRAG \n");
printf ("------- ------- ------- ------- \n");
/* Ga uit van het duurste beest, het paard ... */
for (paard = 1; paard <= (100.00 / 15.00); paard++) {
subtot = paard * 15.00;
/* Varieer dan met het aantal mogelijke varkens ... */
for (varken = 1; varken <= ((100.00 - subtot) / 1.00); varken++) {
kip = 100 - paard - varken;
/* Wat is nu het totaal bedrag aan beesten ... */
bedrag = subtot + varken * 1.00 + kip * 0.25;
/* Indien buiten de grenswaarden, dan het volgende varken ... */
if (((100.00 - 0.50) > bedrag) || (bedrag > (100.00 + 0.50)))
continue;
/* Indien tussen de grenswaarden, druk dan af ... */
printf ("%6d %6d %6d %6.2f", paard, varken, kip, bedrag);
/* BINGO !!! */
if (bedrag == 100.00)
printf (" <====");
/* Sluit de print-regel af */
printf ("\n");
} /* endfor */
} /* endfor */
}
]]>
Er is hier gekozen voor declaratie van variabelen van eenzelfde type op
een regel. Wat verder opvalt is dat het commentaar met de statements is
uitgelijnd. Commentaar en statements zijn bij elkaar gehouden door het
gebruik van blanco regels. Statement groepen zijn twee spaties
ingesprongen, zodat te zien is wat respectievelijk tot de
for's en wat tot de if's behoort.
Het programma genereert mogelijke aankopen en berekent daarvan het
aankoopbedrag. Als dit bedrag niet te veel afwijkt van honderd gulden
wordt de samenstelling afgedrukt. De afwijking in het voorbeeld is
vijftig cent. In het geval het aankoopbedrag precies op honderd gulden
uitkomt, wordt een pijl naast de samenstelling afgedrukt.
Compileer en test het programma. Controleer of het werkt zoals hierboven
beschreven.
| 
