Des boucles qui se répètent, répètent, répètent…

Commençons ce chapitre avec une boucle while. En toute originalité, ce mot-clef est aussi un mot anglais qui signifie « tant que ». Elle exécute une série d’instructions tant que la condition est vraie. Par contre, dès que la condition est évaluée à false, la boucle s’arrête. On dit aussi qu'on boucle ou qu'on itère.

Prenons un exemple tout bête : notre programme va compter de 0 à 9. Voici le code correspondant.

#include <iostream>

int main()
{
    std::cout << "Salut, je vais compter de 0 à 9." << std::endl;
    int compteur { 0 };

    while (compteur < 10)
    {
        std::cout << compteur << std::endl;
        ++compteur;
    }

    std::cout << "Je m'arrête, après je sais pas faire." << std::endl;
    return 0;
}

Le code est exécuté ainsi : on évalue la condition. Tant que compteur est strictement inférieur à 10, alors on affiche le nombre puis on l’incrémente. Quand finalement compteur vaut 10, la condition devient fausse, on passe à la suite du code.

#include <iostream>

int main()
{
    std::cout << "Salut, je vais compter de 0 à 9." << std::endl;
    int compteur { 0 };

    while (compteur < 10)
    {
        std::cout << compteur << std::endl;
        // Oups, on a oublié d'incrémenter le compteur. Nous sommes bloqués dans la boucle.
    }

    std::cout << "Je ne serai jamais affiché." << std::endl;
    return 0;
}

Comme les boucles sont basées sur les conditions, aucun problème pour en utiliser plusieurs en même temps.

#include <iostream>

int main()
{
    char entree { '?' };
    int compteur { 0 };

    // On boucle tant qu'on a pas rentré la lettre 'e' ou que le compteur n'a pas atteint 5.
    while (compteur < 5 && entree != 'e')
    {
        std::cout << "Le compteur vaut " << compteur << std::endl;
        std::cout << "Rentre un caractère : ";
        std::cin >> entree;

        ++compteur;
    }
    
    std::cout << "Fin du programme." << std::endl;
    return 0;
}

Une laverie

Nous allons faire un programme d’aide dans une laverie automatique. Dans celle-ci, deux types de machines sont employées : des machines économes capables de laver 5kg de linge au maximum et d’autres, plus gourmandes, capables de laver 10kg.

• Si le linge fait moins de 5 kg, il faut le mettre dans une machine de 5kg.
• S’il fait entre 5kg et 10kg, il faut le mettre dans une machine de 10kg.
• Enfin, s’il fait plus, il faut répartir le linge entre machines de 10kg et, dès qu’il reste 5kg ou moins, mettre le linge restant dans une machine 5kg.

#include <iostream>

int main()
{
    std::cout << "Bienvenue à la laverie de Clem. Combien de kilos de linge as-tu ? ";
    int kilos { 0 };
    std::cin >> kilos;

    if (kilos <= 5)
    {
        std::cout << "Tu as peu de linge, mets-le dans une machine de 5kg." << std::endl;
    }
    else if (kilos <= 10)
    {
        std::cout << "Tu as beaucoup de linge, mets-le dans une machine de 10kg." << std::endl;
    }
    else
    {
        // On a plus que 10 kilos, il va falloir diviser le linge en plusieurs machines.
        std::cout << "Dites donc, il faut laver son linge plus souvent !" << std::endl;

        int nb_machines_10_kilos { 0 };

        while (kilos > 5)
        {
            // Pour chaque machine de 10kg utilisée, on enlève 10kg au total de linge restant.
            kilos -= 10;
            ++nb_machines_10_kilos;
        }

        std::cout << "Tu as besoin de " << nb_machines_10_kilos << " machine(s) de 10kg." << std::endl;
        if (kilos >= 0)
        {
            // S'il reste entre 0 et 5 kilos, il ne faut pas oublier la dernière machine de 5kg.
            std::cout << "Le reste rentrera dans une machine de 5kg." << std::endl;
        }
    }

    return 0;
}

PGCD

Allez, on va faire un peu de mathématiques ! Le PGCD de deux nombres est un entier qui est le plus grand diviseur que ces deux nombres ont en commun. Ainsi, le PGCD de 427 et 84 est 7, car $427 = 7 \times 61$ et $84 = 7 \times 12$. Pour le calculer, voici l’algorithme.

• On stocke le modulo du premier nombre, appelé a, par l’autre nombre, appelé b, dans une variable r.
• Tant que r est différent de zéro, on effectue les opérations suivantes.
  • On affecte la valeur de b à a.
  • On affecte la valeur de r à b.
  • On affecte à r le résultat du modulo de a par b.
• Quand r est nul, alors b représente le PGCD des deux nombres donnés en entrée.

#include <iostream>

int main()
{
    std::cout << "Rentre un nombre a : ";
    int a { 0 };
    std::cin >> a;

    std::cout << "Rentre un nombre b : ";
    int b { 0 };
    std::cin >> b;

    int r { a % b };
    while (r != 0)
    {
        a = b;
        b = r;
        // r vaut le reste de la division entière de a par b.
        r = a % b;
    }

    std::cout << "PGCD vaut = " << b << std::endl;
    return 0;
}

Somme de nombres de 1 à n

Disons que je vous donne un entier $N$ au hasard. Pouvez-vous me créer un programme capable de me donner la somme de tous les entiers de 1 à $n$, c’est-à-dire la somme de $1 + 2 + 3 + ... + (n - 2) + (n - 1 ) + n$ ?

#include <iostream>

int main()
{
    std::cout << "Donne-moi un entier : ";
    int n { 0 };
    std::cin >> n;

    int total { 0 };
    int compteur { 1 };

    while (compteur <= n)
    {
        total += compteur;
        ++compteur;
    }
    
    std::cout << "La somme totale vaut " << total << "." << std::endl;
    return 0;
}

La deuxième boucle offerte par C++ est très proche de la précédente. En fait, c’est la même, à deux différences près. Une boucle do while s’exécute toujours une fois au minimum, même si la condition est fausse. La condition est en effet vérifiée après l’exécution du code.

La deuxième, c’est qu’il faut un point-virgule après le while. Voyez par vous-mêmes le code suivant.

#include <iostream>

int main()
{
    do
    {
        std::cout << "On passe quand même ici." << std::endl;
    } while (false);

    return 0;
}

Hormis ces deux subtiles différences, do while se comporte exactement comme while et permet elle aussi de boucler. Nous allons voir dans la section suivante comment les deux nous aiderons à résoudre le problème de sécurisation des entrées, soulevé au chapitre précédent.

Dans la première partie, nous avions un mécanisme qui ne nous protégeait qu’une seule fois des erreurs. Maintenant, nous sommes en mesure de nous protéger tant que l’entrée n’est pas correcte. Améliorez donc le code que vous avez écrit pour qu’il soit capable de protéger le code suivant.

#include <iostream>

int main()
{
    std::cout << "Quel jour es-tu né ? ";
    int jour { 0 };
    std::cin >> jour;

    std::cout << "Quel mois es-tu né ? ";
    int mois { 0 };
    std::cin >> mois;

    std::cout << "Tu es né le " << jour << "/" << mois << "." << std::endl;
    return 0;
}

#include <iostream>

int main()
{
    std::cout << "Quel jour es-tu né ? ";
    int jour { 0 };

    // Comme std::cin >> jour renvoie false s'il y a eu une erreur, afin de rentrer dans la boucle, on prend la négation de l'expression avec !
    while (!(std::cin >> jour))
    {
        std::cout << "Entrée invalide. Recommence." << std::endl;
        std::cin.clear();
        std::cin.ignore(255, '\n');
    }

    std::cout << "Quel mois es-tu né ? ";
    int mois { 0 };

    // Même version avec un do while.
    do
    {
        if (std::cin.fail())
        {
            std::cout << "Entrée invalide. Recommence." << std::endl;
            std::cin.clear();
            std::cin.ignore(255, '\n');
        }

    } while (!(std::cin >> mois));

    std::cout << "Tu es né le " << jour << "/" << mois << "." << std::endl;
    return 0;
}

Petit à petit, grâce à nos connaissances qui s’étoffent, nous améliorons la protection des entrées. Mais c’est dommage d’avoir le même code dupliqué à plusieurs endroits. C’est sale, ça nous fait perdre du temps si l’on doit modifier un morceau de code dans chaque endroit ; et je ne parle pas des erreurs liés à des morceaux de codes différents des autres. Nous apprendrons dans le chapitre suivant comment s’en sortir.

Les boucles while et do while sont très utiles et ajoutent une corde à notre arc. Mais ne trouvez-vous pas ça dommage d’avoir nos variables liées à l’itération (comme compteur) séparées de la boucle elle-même ?

Actuellement, notre code est simple, mais imaginons un instant un code bien plus complexe. Il serait mieux de séparer les opérations liées à la boucle de nos autres variables importantes. Cela rendra le code plus clair et plus compréhensible. C’est exactement ce que permet for (« pour » en anglais).

for (/* initialisation */; /* condition */; /* itération */)
{
    // Code de la boucle.
}

// Est équivalent à la boucle ci-dessous.

// Notez la création d'une portée artificielle.
{
    // Initialisation.
    while (/* condition */)
    {
        // Code de la boucle.
        /* itération */
    }
}

Hormis cette syntaxe différente, for s’utilise comme ses consœurs. Nous sommes libres de l’initialisation, de la condition et de l’itération.

#include <iostream>

int main()
{
    // Compte de 10 à 1. On décrémente ici.
    for (int compteur {10}; compteur > 0; --compteur)
    {
        std::cout << compteur << std::endl;
    }
    
    std::cout << "Fin du programme." << std::endl;
    return 0;
}

Nous pouvons même effectuer plusieurs opérations en même temps, tant que les variables déclarées sont du même type. Cette possibilité est cependant à prendre avec des gants parce qu'elle peut rendre le code très peu lisible.

#include <iostream>

int main()
{
    // Compte de 10 à 1 et de 1 à 10 en même temps.
    for (int compteur {10}, compteur_inverse {1}; compteur > 0 && compteur_inverse <= 10; --compteur, ++compteur_inverse)
    {
        std::cout << compteur << " et " << compteur_inverse << std::endl;
    }
    
    std::cout << "Fin du programme." << std::endl;
    return 0;
}

Le choix est vôtre, C++ vous laisse entièrement libre. Après, on utilise plus souvent for dans le cas où l’on veut itérer (compter de 1 à 100 par exemple), alors que while boucle pour réaliser un traitement autant de fois que nécessaire (par exemple, tant que std::cin.fail renvoie true).

Comme pour les conditions, il est tout à fait possible d'imbriquer plusieurs boucles l’une dans l’autre. De même, on peut tout à fait mélanger les types de boucles, comme le prouve l’exemple suivant, qui affiche les tables de multiplications de 1 à 10 en utilisant while et for.

#include <iostream>

int main()
{
    int facteur_gauche { 1 };
    while (facteur_gauche <= 10)
    {
        for (int facteur_droite { 1 }; facteur_droite <= 10; ++facteur_droite)
        {
            std::cout << facteur_gauche << "x" << facteur_droite << " = " << facteur_gauche * facteur_droite << std::endl;
        }
        // On saute une ligne pour séparer chaque table.
        std::cout << std::endl;
        ++facteur_gauche;
    }

    return 0;
}

Dernier point avant de continuer : vous verrez très souvent, tant dans ce tutoriel que dans les divers codes C++ que vous aurez l’occasion d’examiner, que les programmeurs utilisent i comme identifiant de variable pour parcourir une boucle (ainsi que j et k dans le cas de boucles imbriquées). C’est une abréviation pour iterator, parce que cette variable itère, répète le corps de la boucle. Ce nom est tellement court et explicite qu’il est pour ainsi dire devenu une convention de nommage en C++.

Les boucles sont très utiles, mais le code à l’intérieur des accolades est soit entièrement sauté, soit entièrement exécuté. Sachez que C++ permet de contrôler un peu plus précisément l’exécution avec deux mots-clefs : break et continue.

break — Je m’arrête là

Le premier, c’est break, qui en anglais signifie littéralement « casser », « interrompre ». Celui-ci nous autorise à mettre fin à l’exécution de la boucle, peu importe où nous en étions. Dans le code ci-dessous, vous ne verrez jamais afficher les nombres au-dessus de 3 parce que la boucle est terminée par break dès que notre variable vaut 3.

#include <iostream>

int main()
{
    for (int i { 0 }; i < 10; ++i)
    {
        // Si i vaut 3, j'arrête la boucle.
        if (i == 3)
        {
            break;
        }

        std::cout << i << std::endl;
    }
    
    return 0;
}

Dans le cas de boucles imbriquées, break ne stoppe l’exécution que de la boucle dans laquelle il se trouve, mais pas les boucles englobantes.

for (int i { 0 }; i < 5; ++i)
{
    for (int j { 0 }; j < 3; ++j)
    {
        if (j == 1)
        {
            // Quand j vaut 1, on retourne dans le for(i).
            break;
        }

        std::cout << "Voici la valeur de j : " << j << std::endl;
    }

    std::cout << "Voici la valeur de i : " << i << std::endl;
}

Pour illustrer son fonctionnement avec un cas plus utile, prenons un exemple mathématique. Connaissez-vous le concept du test de primalité ? Il s’agit d’un test pour déterminer si un entier est premier, c’est-à-dire divisible uniquement par 1 et par lui-même ; 13 est un nombre premier mais pas 10, car divisible par 1, 2, 5, et 10. Essayez donc de faire cet exercice.

#include <iostream>

int main()
{
    std::cout << "Donne-moi un nombre, je te dirai s'il est premier : ";
    int nombre { 0 };
    std::cin >> nombre;

    bool est_premier { true };
    for (int i { 2 }; i < nombre; ++i)
    {
        if (nombre % i == 0)
        {
            // Si i divise nombre, alors nous savons que nombre n'est pas premier.
            est_premier = false;
            break;
        }
    }
    
    if (est_premier)
    {
        std::cout << nombre << " est un nombre premier !" << std::endl;
    }
    else
    {
        std::cout << nombre << " n'est pas premier." << std::endl;
    }

    return 0;
}

continue — Saute ton tour !

L’autre mot-clef, continue, permet de sauter l’itération courante. Toutes les instructions qui se trouvent après ce mot-clef sont donc ignorées et la boucle continue au tour suivant. Imaginons que nous voulions un programme permettant d’afficher les nombres impairs compris entre 0 et un nombre choisi par l’utilisateur. Essayez donc de le faire, avec les connaissances que vous avez.

#include <iostream>

int main()
{
    std::cout << "Donne-moi un nombre, je t'afficherai tous les nombres impairs jusqu'à ce nombre : ";
    int maximum { 0 };
    std::cin >> maximum;

    for (int i { 0 }; i <= maximum; ++i)
    {
        if (i % 2 == 0)
        {
            // On saute ce nombre puisqu'il est pair.
            continue;
        }

        std::cout << i << std::endl;
    }

    return 0;
}

int i { 0 };
while (i < 10)
{
    if (i == 5)
    {
        // Ohoh...
        continue;
    }

    ++i;
}