Les boucles while et do while

Approfondir : Les boucles while et do while

Une boucle répète un traitement sans recopier ses instructions. Après la boucle for, on étudie ici while et do while : leur différence tient au moment où la condition est évaluée. On commence par une trace manuelle pour comprendre pourquoi une boucle s’arrête.

while : tester avant d’entrer

La forme while (condition) { traitement; } évalue la condition avant chaque tour. Si elle est fausse dès le départ, le corps n’est jamais exécuté. Il faut initialiser les variables utilisées par la condition avant ce premier test. Dans une somme de 1 à n, on peut partir de i=1 et somme=0 ; après chaque ajout, i augmente.

L’invariant et la progression

Une boucle doit préserver une propriété utile et progresser vers sa sortie. Juste avant le tour d’indice i, somme contient ici 1+...+(i-1). Ajouter i rend cette somme correcte jusqu’à i ; incrémenter i prépare le tour suivant. Oublier cette incrémentation peut rendre la boucle infinie. Un invariant n’est pas un mot magique : c’est une phrase que l’on peut vérifier à l’initialisation, après un tour et à la sortie.

do while : exécuter au moins une fois

La forme do { traitement; } while (condition); effectue d’abord le corps, puis le test. Le point-virgule après la parenthèse finale fait partie de cette syntaxe. Cette boucle convient lorsque l’on doit nécessairement effectuer une première lecture ou afficher une première proposition. Elle ne dispense pas de gérer l’échec d’une lecture.

Une sentinelle n’est pas une donnée à accumuler

Une sentinelle est une valeur réservée qui demande l’arrêt, par exemple zéro pour terminer une série de nombres positifs. Il faut lire, tester la sentinelle, puis décider d’ajouter ou non la donnée. Si zéro représente une mesure valide, choisir un autre mécanisme, comme un nombre d’éléments annoncé. Le sens de l’entrée doit donc être défini avant la boucle.

Choisir une boucle

Quand le nombre de tours est connu, for exprime clairement l’initialisation, le test et la progression. Quand le traitement dépend d’un événement, while est souvent naturel. Quand un premier tour est obligatoire, do while évite de dupliquer le premier traitement. Les trois formes peuvent souvent exprimer le même algorithme ; on choisit celle qui rend les conditions d’arrêt les plus visibles.

Boucles : somme de 1 à n

#include <stdio.h>
int main(void) {
    int n, i = 1;
    long somme = 0;
    puts("Entrer n entre 0 et 1000 :");
    if (scanf("%d", &n) != 1 || n < 0 || n > 1000) {
        puts("Saisie invalide.");
        return 1;
    }
    while (i <= n) {
        somme += i;
        ++i;
    }
    printf("Somme = %ld\n", somme);
    printf("Indice final = %d\n", i);
    return 0;
}

Sortie écran : essai 1

Trois tours, puis arrêt sur le quatrième test.

Entrer n entre 0 et 1000 :
3
Somme = 6
Indice final = 4

Sortie écran : essai 2

while peut faire zéro tour.

Entrer n entre 0 et 1000 :
0
Somme = 0
Indice final = 1

Boucles : premier tour avec do while

#include <stdio.h>
int main(void) {
    int i = 0;
    do {
        printf("Tour %d\n", i);
        ++i;
    } while (i < 0);
    printf("Apres : %d\n", i);
    return 0;
}

Sortie écran : essai 1

Le corps est exécuté une fois malgré une condition finale fausse.

Tour 0
Apres : 1

S’entraîner et vérifier

#include <stdio.h>
int main(void) {
    int n, i = 1;
    long somme = 0;
    puts("Entrer n entre 0 et 1000 :");
    if (scanf("%d", &n) != 1 || n < 0 || n > 1000) {
        puts("Saisie invalide.");
        return 1;
    }
    for (i = 1; i <= n; ++i) {
        somme += i;
    }
    printf("Somme = %ld\n", somme);
    printf("Indice final = %d\n", i);
    return 0;
}

Entrer n entre 0 et 1000 :
3
Somme = 6
Indice final = 4

Pratiquer avec le TD/TP 1 corrigé · Tous les exercices C.

Repère de lecture : les codes proposés utilisent des constructions disponibles en C11. Les règles du langage et de sa bibliothèque sont consultables dans les projets publics du WG14 (C11) et du WG14 (C23). Les exemples n’utilisent pas les nouveautés propres à C23.