Boucle do-while en C : syntaxe, exemples et cas d'usage

La boucle qui s'exécute toujours une fois

Une boucle while teste avant d'agir, elle peut donc s'exécuter zéro fois. C'est généralement ce qu'il faut. Parfois c'est exactement l'inverse : vous ne pouvez pas savoir s'il faut répéter une invite avant de l'avoir affichée, et vous ne pouvez pas juger la saisie d'un utilisateur avant d'en avoir lu un peu. do-while déplace le test à la fin : le corps s'exécute d'abord et la condition décide seulement s'il faut recommencer.

#include <stdio.h>

int main(void) {
    int i = 10;

    printf("while (i < 5) :\n");
    while (i < 5) {
        printf("  ceci ne s'affiche jamais\n");
    }

    printf("do ... while (i < 5) :\n");
    do {
        printf("  ceci s'affiche une fois, i = %d\n", i);
    } while (i < 5);

    return 0;
}

La condition i < 5 est fausse dès le départ. La boucle while s'exécute zéro fois ; la do-while exactement une. C'est toute la différence entre elles.

La syntaxe, et ce point-virgule

do {
    // corps - s'execute toujours au moins une fois
} while (condition);

L'ordre se lit comme il s'exécute : fais le corps, tant que la condition tient, refais-le.

Le point-virgule final après la parenthèse fermante est obligatoire. do ... while (cond); est une instruction, et les instructions C se terminent par un point-virgule. Omettez-le et le compilateur continue de lire, puis signale une erreur de syntaxe plus bas - c'est pourquoi la vraie faute est souvent à plusieurs lignes de celle que l'erreur pointe.

C'est aussi le seul endroit en C où while (cond); avec un point-virgule est correct plutôt qu'un bug. Dans une simple boucle while, la même ponctuation crée un corps vide et généralement une boucle infinie ; ici, elle ferme un do.

Les accolades sont facultatives pour un corps d'une seule instruction mais, comme pour toute autre structure de contrôle C, écrivez-les quand même.

Le motif de validation de saisie

C'est ce pour quoi do-while a été conçu. Vous devez lire quelque chose avant de pouvoir dire si c'est acceptable, donc la lecture doit avoir lieu avant le test :

#include <stdio.h>

int main(void) {
    /* substituts de ce qu'un utilisateur pourrait taper */
    int attempts[] = {-4, 0, 130, 27};
    int index = 0;
    int age;

    do {
        age = attempts[index];
        printf("Lu : %d\n", age);
        index++;
    } while (age < 1 || age > 120);

    printf("Age accepte : %d\n", age);
    return 0;
}

La boucle continue de lire jusqu'à ce qu'une valeur passe, et la condition même qui rejette une mauvaise valeur est celle qui demande un nouveau passage. Écrite en while, la lecture devrait apparaître deux fois - une avant la boucle pour amorcer la condition, une à la fin du corps - c'est cette duplication que do-while supprime.

Avec une vraie saisie, le corps appellerait scanf :

int age;
do {
    printf("Entrez votre age (1-120) : ");
    if (scanf("%d", &age) != 1) {
        while (getchar() != '\n') { }   /* jeter la ligne fautive */
        age = -1;                        /* forcer un nouveau passage */
    }
} while (age < 1 || age > 120);

Notez le while interne qui vide le reste de la ligne. Si scanf échoue à convertir, le texte fautif reste dans le tampon d'entrée et toutes les lectures ultérieures échouent dessus aussi - une boucle qui tourne indéfiniment en affichant l'invite. Le vider fait partie du motif.

Le motif du menu

L'autre usage classique : afficher les options, lire un choix, agir dessus, et répéter jusqu'à ce que l'utilisateur quitte. Le menu doit apparaître avant qu'il y ait un choix à tester.

#include <stdio.h>

int main(void) {
    int choices[] = {2, 1, 3, 4};   /* frappes simulees */
    int i = 0;
    int choice;

    do {
        printf("\n--- Menu ---\n");
        printf("1. Dire bonjour\n");
        printf("2. Afficher la date\n");
        printf("3. Ne rien faire\n");
        printf("4. Quitter\n");

        choice = choices[i];
        i++;
        printf("Vous avez choisi : %d\n", choice);

        switch (choice) {
            case 1:  printf("Bonjour !\n");          break;
            case 2:  printf("2026-09-18\n");         break;
            case 3:  printf("Comme demande.\n");     break;
            case 4:  printf("Au revoir.\n");         break;
            default: printf("Option inconnue.\n");   break;
        }
    } while (choice != 4);

    return 0;
}

Le break dans le switch termine le switch, pas la boucle - un point qui mérite d'être précis, puisque les deux utilisent le même mot-clé. Ici, la boucle se termine parce que choice != 4 devient faux. Si vous vouliez vraiment quitter la boucle depuis le switch, return ou une variable drapeau seraient la solution ; break seul ne peut pas le faire.

Un premier passage garanti peut être un bug

Parce que le corps s'exécute avant tout test, do-while traitera volontiers des données qui n'existent pas :

/* BUG: affiche a[0] meme quand n vaut 0 */
int i = 0;
do {
    printf("%d\n", a[i]);
    i++;
} while (i < n);

Avec n == 0, ceci lit a[0] sur un tableau vide - comportement indéfini. Toute boucle sur une collection potentiellement vide veut un while ou un for, dont le test vient en premier.

La règle empirique : n'utilisez do-while que quand une exécution à zéro itération est impossible par nature du problème, et non simplement improbable en pratique. Interroger un utilisateur, lancer des dés jusqu'à obtenir une cible, générer et tester un candidat - tout cela ne peut réellement pas être jugé avant le premier passage. Parcourir une liste ne peut pas prétendre à cela.

break et continue dans un do-while

Les deux fonctionnent, et continue a une subtilité à connaître : il saute vers le test de condition, pas vers le début du corps.

#include <stdio.h>

int main(void) {
    int i = 0;

    do {
        i++;
        if (i % 2 == 0) {
            continue;        /* saute vers le test while, pas vers le haut du corps */
        }
        printf("%d ", i);
    } while (i < 10);

    printf("\n");
    return 0;
}

Le i++ en haut du corps s'exécute à chaque passage, y compris ceux que continue interrompt, donc la boucle avance quand même. Mettez la mise à jour après un continue et la boucle bloque - le même piège que dans les boucles while.

break quitte la boucle immédiatement et saute entièrement la condition.

Choisir entre les trois boucles

Les trois boucles du C sont également puissantes ; le choix porte sur celle qui exprime l'intention.

for        un compteur, sa limite et son pas vont ensemble - "n fois"
while      repeter jusqu'a ce qu'une condition change, peut-etre jamais - "jusqu'a"
do-while   pareil, mais le premier passage est garanti - "au moins une fois"

En pratique, do-while est de loin la plus rare des trois. La plupart des boucles soit comptent, soit doivent gérer le cas vide, et les deux veulent le test en haut. Prenez do-while quand vous vous surprenez à dupliquer une instruction juste avant une boucle while pour amorcer sa condition - cette duplication est le signal.