Boucle while en C++ : syntaxe, do-while et pièges

Quand vous n'avez pas de compteur

La boucle for est construite autour d'un compteur que vous définissez d'emblée. Mais beaucoup de boucles n'ont pas de décompte net : continuer à lire des nombres jusqu'à ce que la saisie s'épuise, continuer à demander un mot de passe jusqu'à ce qu'il soit correct, continuer à diviser une valeur par deux jusqu'à atteindre 1. Pour ces cas, la boucle while s'impose naturellement : elle répète simplement tant qu'une condition reste vraie.

Une boucle while teste sa condition avant chaque passage, y compris le tout premier. Si la condition est fausse dès le départ, le corps ne s'exécute jamais.

#include <iostream>
using namespace std;

int main() {
    int count = 3;

    while (count > 0) {
        cout << "Liftoff in " << count << "\n";
        count--;
    }

    cout << "Go!\n";
}

La condition count > 0 est testée en premier ; si elle est vraie, le corps s'exécute, puis on reboucle et on teste à nouveau. La ligne count-- est ce qui finit par rendre la condition fausse : supprimez-la et la boucle tourne indéfiniment.

L'anatomie d'une boucle while

Comparez-la à la boucle for en trois parties que vous connaissez déjà. Une boucle while sépare ces trois tâches : vous faites l'initialisation avant la boucle, la condition va entre les parenthèses et la mise à jour vit à l'intérieur du corps.

int i = 0;          // initialisation - avant la boucle
while (i < 5) {     // condition - testée à chaque passage
    cout << i << "\n";
    i++;            // mise à jour - vous devez y penser vous-même
}

C'est cette dernière partie qui est piégeuse. Dans une boucle for, la mise à jour est juste à côté de la condition, donc difficile à oublier. Dans une boucle while, ce n'est qu'une instruction de plus dans le corps : l'erreur la plus courante est de l'oublier et de bloquer le programme.

Un piège du C++ qui surprend les débutants : un point-virgule égaré juste après la condition transforme le corps en une instruction vide.

int i = 0;
while (i < 5);   // <-- ce point-virgule est tout le corps de la boucle
{
    cout << i << "\n";
    i++;
}

Cela tourne indéfiniment sans rien faire, car le ; est le corps et i ne change jamais. Le bloc entre accolades s'exécute alors exactement une fois. Le compilateur ne vous arrêtera pas : c'est un code parfaitement légal, simplement pas ce que vous vouliez dire.

do-while : exécuter le corps au moins une fois

Parfois, vous avez besoin que le corps s'exécute une fois avant de pouvoir même décider de recommencer. La boucle do-while teste sa condition à la fin, donc le corps s'exécute toujours au moins une fois :

#include <iostream>
using namespace std;

int main() {
    int number;

    do {
        cout << "Enter a positive number: ";
        cin >> number;
    } while (number <= 0);

    cout << "Thanks! You entered " << number << "\n";
}

Vous devez demander et lire au moins une fois avant de savoir si la saisie est valide, ce qui est exactement ce que do-while vous offre. Notez le point-virgule après while (...) : en C++ il est obligatoire pour do-while, et l'oublier est une erreur de compilation fréquente.

La différence avec un while ordinaire apparaît clairement quand la condition est fausse dès le départ :

#include <iostream>
using namespace std;

int main() {
    int x = 10;

    // while : condition fausse d'emblée -> le corps ne s'exécute jamais
    while (x < 5) {
        cout << "while body\n";
    }

    // do-while : s'exécute une fois, PUIS teste -> le corps s'exécute exactement une fois
    do {
        cout << "do-while body\n";
    } while (x < 5);
}

Seul do-while body s'affiche. La boucle while saute entièrement son corps car x < 5 était faux avant le premier test.

Boucler jusqu'à l'échec de cin

Un usage classique de while est de lire jusqu'à ce que la saisie s'arrête : il n'y a pas de compteur, vous continuez simplement jusqu'à ce que le flux vous dise de quitter. En C++, cin >> value s'évalue comme le flux lui-même, qui est vrai tant que la lecture réussit et faux dès qu'il atteint la fin de la saisie ou un type incompatible. Cela en fait une condition de boucle nette :

#include <iostream>
using namespace std;

int main() {
    int value;
    int sum = 0;

    cout << "Enter numbers to add (Ctrl+D / non-number to finish):\n";

    while (cin >> value) {
        sum += value;
    }

    cout << "Total: " << sum << "\n";
}

La condition remplit un double rôle : elle lit et teste en une seule étape. Comparez avec une valeur sentinelle, disons s'arrêter sur 0. Là, vous devez lire une fois avant la boucle et à nouveau à la fin de chaque passage pour que la condition teste toujours une saisie fraîche :

#include <iostream>
using namespace std;

int main() {
    int value;
    int sum = 0;

    cout << "Enter numbers to add (0 to finish):\n";
    cin >> value;

    while (value != 0) {
        sum += value;
        cin >> value;   // oubliez cette ligne et 'value' ne change jamais -> boucle infinie
    }

    cout << "Total: " << sum << "\n";
}

Si vous oubliez la seconde lecture dans le corps, value ne change jamais et vous avez une boucle infinie. La forme while (cin >> value) contourne cela en intégrant la lecture dans la condition.

break et continue dans les boucles while

break et continue fonctionnent ici de la même façon que dans une boucle for. break quitte la boucle immédiatement ; continue saute directement au test de la condition, en ignorant le reste du passage en cours :

#include <iostream>
using namespace std;

int main() {
    int n = 0;

    while (true) {                  // "boucle infinie" intentionnelle
        n++;
        if (n % 2 == 0) continue;   // ignorer les nombres pairs
        if (n > 9) break;           // s'arrêter une fois passé 9
        cout << n << " ";
    }
    cout << "\n";
}

Cela affiche 1 3 5 7 9. Le while (true) ne s'arrête délibérément jamais de lui-même : le break est la seule sortie. Soyez prudent avec continue dans une boucle while : comme la mise à jour fait partie du corps, sauter en haut avec continue avant d'avoir fait avancer votre compteur est un moyen discret de bloquer la boucle. Dans l'exemple ci-dessus, n++ s'exécute en premier, donc c'est sûr.

Attention aux boucles infinies

La condition doit finir par devenir fausse, et cela dépend entièrement de quelque chose qui change à l'intérieur du corps. Les deux coupables habituels sont d'oublier la mise à jour et de mettre à jour d'une manière qui dépasse la valeur de sortie :

int i = 0;
while (i < 5) {
    cout << i << "\n";   // i ne change jamais -> tourne indéfiniment
}

int i = 0;
while (i != 10) {
    i += 3;   // 0, 3, 6, 9, 12... dépasse pile 10 -> tourne indéfiniment
}

La première se bloque car i n'est jamais mis à jour. La seconde se bloque car le compteur dépasse la valeur exacte que la condition recherche : préférez < ou <= à != quand le pas risque de ne pas tomber juste. Un while (true) est correct s'il a un break garanti ; un accidentel n'est qu'un bug. Et souvenez-vous du piège du corps vide while (...); vu plus haut : un point-virgule mal placé produit une boucle infinie qui paraît correcte au premier coup d'œil.

Suivant : la boucle for basée sur un intervalle

Une boucle while est l'outil approprié quand vous bouclez jusqu'à ce qu'une condition change et qu'il n'y a pas de décompte net. Mais quand vous voulez simplement parcourir chaque élément d'un conteneur (un vector, un tableau, une string) sans indice ni condition à gérer, le C++ moderne offre quelque chose de plus propre : la boucle for basée sur un intervalle (for (auto x : container)). C'est le sujet de la page suivante.