Maîtriser les boucles en C : For, While et Do-While expliqués avec exemples pratiques

Qu'est-ce qu'une boucle en C ?

Une boucle répète un bloc d'instructions jusqu'à ce qu'une condition spécifiée devienne fausse. En C, une boucle se compose d'un corps et d'une instruction de contrôle qui dicte combien de fois le corps s'exécute. Maîtriser les boucles est essentiel pour écrire des programmes C efficaces et lisibles.

Dans ce tutoriel, vous découvrirez :

• Définition et but des boucles en C
• Types de boucles : contrôlées à l'entrée vs contrôlées à la sortie
• Fondamentaux de la boucle while
• Fondamentaux de la boucle do-while
• Fondamentaux de la boucle for
• Utilisation de break et continue
• Choisir la bonne boucle pour un scénario donné

Types de boucles en C

Les boucles C sont classées par la position de leur condition de contrôle :

• Boucles contrôlées à l'entrée (entry-controlled) – la condition est évaluée avant que le corps ne s'exécute (ex. while et for).
• Boucles contrôlées à la sortie (exit-controlled) – la condition est évaluée après que le corps s'exécute (ex. do-while).

Une boucle infinie se produit lorsque la boucle ne satisfait jamais sa condition de terminaison. Causes courantes : absence de vérification de terminaison ou condition toujours vraie.

Boucle while en C

La boucle while est la forme la plus simple de boucle contrôlée à l'entrée. Sa syntaxe est :

while (condition) {
    instructions;
}

La condition est évaluée en premier ; si elle est vraie, le corps s'exécute. Après chaque exécution, la condition est réévaluée jusqu'à ce qu'elle devienne fausse.

Exemple – afficher les nombres de 1 à 10 :

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

Sortie :

1 2 3 4 5 6 7 8 9 10

Boucle do-while en C

La boucle do-while garantit que le corps s'exécute au moins une fois, ce qui en fait une boucle contrôlée à la sortie. Syntaxe :

do {
    instructions;
} while (condition);

Exemple – afficher la table de multiplication de 2 jusqu'à 10 :

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

Sortie :

2 4 6 8 10 12 14 16 18 20

Boucle for en C

La boucle for est très efficace pour itérer avec un début, une fin et un pas connus. Syntaxe :

for (initialisation; condition; incrément) {
    instructions;
}

• L'initialisation s'exécute une fois.
• La condition est vérifiée avant chaque itération.
• L'incrément met à jour la variable de boucle.

Exemple – afficher les nombres de 1 à 10 :

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

Sortie :

1 2 3 4 5 6 7 8 9 10

Les boucles for complexes peuvent inclure plusieurs expressions et même des composants vides :

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

Les boucles imbriquées sont courantes, surtout pour les tableaux multidimensionnels. Exemple – tables de multiplication :

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

Sortie :

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

Instruction break en C

Le mot-clé break quitte immédiatement la boucle ou l'instruction switch la plus proche. Exemple – arrêter une boucle while quand une valeur atteint 3 :

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

Sortie :

5 4

Instruction continue en C

Le mot-clé continue saute le reste de l'itération courante et passe au cycle de boucle suivant. Exemple – sauter l'affichage du nombre 5 :

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

Sortie :

6 4 3 2 1

Choisir la bonne boucle

Décidez en fonction du moment où la condition doit être évaluée :

• Pré-test requis – utilisez while ou for.
• Post-test requis – utilisez do-while.

Résumé

• Une boucle répète un bloc de code jusqu'à ce que sa condition devienne fausse.
• Le C offre trois boucles principales : while, do-while et for.
• Les boucles contrôlées à l'entrée évaluent la condition avant chaque itération ; les boucles contrôlées à la sortie évaluent après.
• Utilisez break pour terminer les boucles prématurément et continue pour sauter des itérations.
• Choisissez la boucle qui correspond le mieux aux exigences de flux de contrôle de votre algorithme.