Tot nu toe moest je je programma steeds opnieuw starten wanneer je een berekening voor een nieuw probleem wilde uitvoeren. Dat is natuurlijk niet erg efficiënt. Vaak wil je net dezelfde instructies meerdere keren herhalen.

Een iteratie is zo’n herhalingsstructuur. Ze laat een opeenvolging van instructies een aantal keren herhalen. Je spreekt ook wel van een lus.

In C# bestaan er meerdere soorten lussen, wij zien de belangrijkste: de while-lus en de for-lus. In deze reeks bekijken we de while-lus.

Herhalen zolang als

De while-lus herhaalt de instructies zolang aan een voorwaarde voldaan is. De naam zegt het zelf: while is het Engels voor “herhaal zolang”. Zodra niet meer aan de voorwaarde voldaan is, stopt de lus en gaat het programma verder met de opdracht na de lus.

while (voorwaarde)
{
    // statements: de instructies die herhaald worden
}

Schematisch ziet een while-lus er zo uit:

Stroomdiagram van een while-lus Vraag eerst een waarde voor de variabele uit de voorwaarde. Test de voorwaarde. Is ze waar, voer dan de instructies van de lus uit en pas aan het einde diezelfde variabele aan. Test opnieuw met de aangepaste waarde. Is de voorwaarde onwaar, ga dan verder na de lus. Vraag/Bepaal een beginwaarde voor de variabele in de testvoorwaarde Is de testvoorwaarde waar? Voer de instructies van de lus uit Pas diezelfde variabele (van voor de test) aan Vraag bv. een nieuwe waarde Ga verder na de lus Ja Nee Test opnieuw

De voorwaarde wordt eerst getest, en pas daarna worden de instructies uitgevoerd. Is de voorwaarde al van bij de start false, dan draait de lus dus nul keer.

De voorwaarde moet ooit false worden

Dit is het belangrijkste om te onthouden: er moet binnen de lus iets veranderen waardoor de voorwaarde uiteindelijk false wordt. Gebeurt dat niet, dan blijft de voorwaarde eeuwig true en draait de lus voor altijd door. Dat noemen we een oneindige lus, en dat is bijna nooit de bedoeling.

Daarom hoort bij elke while-lus meestal een vast patroon van drie ingrediënten:

IngrediëntWat het doet
InitialisatieStel vóór de lus een beginwaarde in voor de variabele die je in de voorwaarde gebruikt.
VoorwaardeDe test bovenaan de lus die bepaalt of er nog een ronde volgt.
UpdateVerander in het lichaam die variabele, zodat de voorwaarde ooit false wordt.

Vergeet je de update, dan verandert de variabele nooit en krijg je een oneindige lus. Dat is de klassieke beginnersfout bij lussen.

Een uitgewerkt voorbeeld: de hallo-teller

Bekijken we een concreet voorbeeld. We willen een programma dat zo werkt:

De gebruiker geeft een aantal keer een strikt positief geheel getal in (dus groter dan 0). Telkens toont het programma de tekst Hallo. Geeft de gebruiker een negatief getal of 0 in, dan toont het programma hoe vaak het Hallo heeft getoond.

We hebben twee variabelen nodig: getal (het getal dat de gebruiker ingeeft) en aantal (een teller die we bijhouden). De teller begint op 0 en gaat telkens één omhoog wanneer we Hallo tonen.

Stroomdiagram van de hallo-teller Zet aantal op nul en lees het eerste getal in. Is het getal groter dan nul, toon dan Hallo, verhoog aantal met één en lees een nieuw getal in. Ga terug naar de voorwaarde. Anders toon je hoe vaak Hallo is getoond en stop je. Zet aantal op 0 Lees het eerste getal in Is getal > 0? Toon ‘Hallo’ Verhoog aantal met 1 aantal = aantal + 1 Lees een nieuw getal in Toon aantal en stop Ja Nee
// Declaratie van de variabelen
int getal;
int aantal = 0;

// Eerste invoer
//Console.Write("Geef een getal: ");
getal = Convert.ToInt32(Console.ReadLine());

while (getal > 0)
{
    Console.WriteLine("Hallo");
    aantal = aantal + 1;
    //Console.Write("Geef een getal: ");
    getal = Convert.ToInt32(Console.ReadLine());
}

// Resultaat tonen
Console.WriteLine("Aantal keer 'Hallo' getoond: " + aantal);

Herken je de drie ingrediënten?

IngrediëntIn dit programma
Initialisatieint aantal = 0; en het eerste getal dat we vóór de lus inlezen.
Voorwaardegetal > 0: zolang de gebruiker een strikt positief getal ingeeft.
UpdateIn het lichaam lezen we met getal = Convert.ToInt32(Console.ReadLine()); een nieuw getal in. Daardoor kan de voorwaarde ooit false worden.

Merk op dat we vóór de lus al een eerste getal inlezen. Anders zou de voorwaarde getal > 0 getest worden vóór getal een waarde heeft. En binnen de lus lezen we op het einde telkens een nieuw getal in: dat is de update die de lus ooit doet stoppen.

Geeft de gebruiker bijvoorbeeld achtereenvolgens 4, 7, 2 en dan 0 in, dan ziet de uitvoer er zo uit:

Geef een getal: 4
Hallo
Geef een getal: 7
Hallo
Geef een getal: 2
Hallo
Geef een getal: 0
Aantal keer 'Hallo' getoond: 3

Geeft de gebruiker meteen 0 of een negatief getal in, dan is de voorwaarde van bij de start false. De lus draait dan nul keer en het programma toont:

Geef een getal: 0
Aantal keer 'Hallo' getoond: 0

Een uitgewerkt voorbeeld: het kassaprogramma

Je maakt een kassaprogramma dat de aankoop van één klant afrekent. Voor elk artikel geeft de kassier de prijs per stuk en het aantal stuks in. In dit voorbeeld werken we met prijzen in hele euro’s.

Vóór de lus zet je totaal op 0 en vraag je de eerste prijs per stuk. De voorwaarde prijs > 0 bepaalt of het programma het artikel verwerkt.

In de lus vraag je het aantal stuks. Je berekent het bedrag voor dat artikel met prijs * aantal en telt het bij totaal op. Onderaan de lus vraag je de volgende prijs per stuk. Je bewaart die in prijs, zodat de volgende controle met de nieuwe prijs gebeurt.

Na de lus toon je het eindtotaal. Zodra de kassier een prijs van 0 of minder ingeeft, slaat het programma de vraag naar het aantal over.

Stroomdiagram van het kassaprogramma Zet het totaal op nul en vraag de eerste prijs. Is de prijs groter dan nul, vraag dan het aantal, tel prijs maal aantal bij het totaal, vraag de volgende prijs en keer terug naar de voorwaarde. Anders toon je het eindtotaal en stop je. Zet totaal op 0 Vraag de eerste prijs Is prijs > 0? Vraag het aantal Bereken het nieuwe totaal totaal = totaal + prijs × aantal Vraag de volgende prijs per stuk Toon eindtotaal en stop Ja Nee
int totaal = 0;

Console.Write("Geef de prijs per stuk: ");
int prijs = Convert.ToInt32(Console.ReadLine());

while (prijs > 0)
{
    Console.Write("Geef het aantal: ");
    int aantal = Convert.ToInt32(Console.ReadLine());
    totaal = totaal + prijs * aantal;

    Console.Write("Geef de volgende prijs per stuk: ");
    prijs = Convert.ToInt32(Console.ReadLine());
}

Console.WriteLine("Eindtotaal: " + totaal + " euro");

Bij het eerste artikel kost elk stuk 2 euro. Voor 3 stuks wordt het totaal 6 euro. Bij het tweede artikel kosten 2 stuks van elk 4 euro samen 8 euro. Het nieuwe totaal is dus 14 euro.

Geef de prijs per stuk: 2
Geef het aantal: 3
Geef de volgende prijs per stuk: 4
Geef het aantal: 2
Geef de volgende prijs per stuk: 0
Eindtotaal: 14 euro

Geeft de kassier meteen 0 in, dan voert het programma de lus nul keer uit en toont het Eindtotaal: 0 euro.