C Lussen Beheersen: For, While en Do-While Uitgelegd met Praktische Voorbeelden

Wat is een Lus in C?

Een lus herhaalt een blok statements totdat een gespecificeerde voorwaarde false wordt. In C bestaat een lus uit een body en een controlestatement dat dicteert hoe vaak de body uitgevoerd wordt. Het beheersen van lussen is essentieel voor het schrijven van efficiënte en leesbare C-programma's.

In deze tutorial ontdek je:

• Definitie en doel van lussen in C
• Typen lussen: entry-controlled vs. exit-controlled
• While-lus fundamentals
• Do-while-lus fundamentals
• For-lus fundamentals
• break en continue gebruiken
• De juiste lus kiezen voor een gegeven scenario

Typen Lussen in C

C-lussen worden geclassificeerd op basis van de positie van hun controlevoorwaarde:

• Entry-controlled lussen – de voorwaarde wordt geëvalueerd vóór de body draait (bijv. while en for).
• Exit-controlled lussen – de voorwaarde wordt geëvalueerd ná de body draait (bijv. do-while).

Een oneindige lus ontstaat wanneer de lus nooit aan haar beëindigingsvoorwaarde voldoet. Veelvoorkomende oorzaken zijn het missen van een beëindigingscheck of een altijd-true voorwaarde.

While-lus in C

De while-lus is de simpelste vorm van een entry-controlled lus. De syntaxis is:

while (voorwaarde) { statements; }

De voorwaarde wordt eerst geëvalueerd; als deze true is, voert de body uit. Na elke uitvoering wordt de voorwaarde opnieuw geëvalueerd totdat deze false wordt.

Voorbeeld – print getallen 1 tot 10:

#include <stdio.h>
int main() {
    int num = 1;
    while (num <= 10) {
        printf("%d\n", num);
        num++;
    }
    return 0;
}

Output:

1 2 3 4 5 6 7 8 9 10

Do-While-lus in C

De do-while-lus garandeert dat de body minstens één keer uitgevoerd wordt, wat het een exit-controlled lus maakt. Syntaxis:

do { statements; } while (voorwaarde);

Voorbeeld – print de tafel van 2 tot 10:

#include <stdio.h>
int main() {
    int num = 1;
    do {
        printf("%d\n", 2 * num);
        num++;
    } while (num <= 10);
    return 0;
}

Output:

2 4 6 8 10 12 14 16 18 20

For-lus in C

De for-lus is zeer efficiënt voor itereren met een bekende start, einde en stap. Syntaxis:

for (initialisatie; voorwaarde; increment) { statements; }

• De initialisatie draait één keer.
• De voorwaarde wordt gecheckt voor elke iteratie.
• De increment werkt de lusvariabele bij.

Voorbeeld – print getallen 1 tot 10:

#include <stdio.h>
int main() {
    for (int number = 1; number <= 10; number++) {
        printf("%d\n", number);
    }
    return 0;
}

Output:

1 2 3 4 5 6 7 8 9 10

Complexe for-lussen kunnen meerdere expressies en zelfs lege componenten bevatten:

for (int i = 0, j = num; i < j; i++, j--) {
    // statements
}

Geneste lussen zijn veelvoorkomend, vooral voor multidimensionale arrays. Voorbeeld – tafels:

#include <stdio.h>
int main() {
    int i, j;
    int tafel = 2;
    int max = 5;
    for (i = 1; i <= tafel; i++) {
        for (j = 0; j <= max; j++) {
            printf("%d x %d = %d\n", i, j, i * j);
        }
        printf("\n");
    }
    return 0;
}

Output:

1 x 0 = 0
1 x 1 = 1
1 x 2 = 2
1 x 3 = 3
1 x 4 = 4
1 x 5 = 5
2 x 0 = 0
2 x 1 = 2
2 x 2 = 4
2 x 3 = 6
2 x 4 = 8
2 x 5 = 10

Break-statement in C

Het break-sleutelwoord verlaat de dichtstbijzijnde omsluitende lus of switch-statement onmiddellijk. Voorbeeld – stop een while-lus wanneer een waarde 3 bereikt:

#include <stdio.h>
int main() {
    int num = 5;
    while (num > 0) {
        if (num == 3) break;
        printf("%d\n", num);
        num--;
    }
    return 0;
}

Output:

5 4

Continue-statement in C

Het continue-sleutelwoord slaat de rest van de huidige iteratie over en gaat door naar de volgende luscyclus. Voorbeeld – sla het printen van getal 5 over:

#include <stdio.h>
int main() {
    int nb = 7;
    while (nb > 0) {
        nb--;
        if (nb == 5) continue;
        printf("%d\n", nb);
    }
    return 0;
}

Output:

6 4 3 2 1

De Juiste Lus Kiezen

Beslis op basis van wanneer de voorwaarde geëvalueerd moet worden:

• Pre-test vereist – gebruik while of for.
• Post-test vereist – gebruik do-while.

Samenvatting

• Een lus herhaalt een blok code totdat zijn voorwaarde false wordt.
• C biedt drie primaire lussen: while, do-while en for.
• Entry-controlled lussen evalueren de voorwaarde vóór elke iteratie; exit-controlled lussen evalueren erna.
• Gebruik break om lussen vroegtijdig te beëindigen en continue om iteraties over te slaan.
• Kies de lus die het beste past bij de controlestroomvereisten van je algoritme.