Apprenez à programmer en C++

Les boucles vous permettent de répéter les mêmes instructions plusieurs fois dans votre programme :

1. L'ordinateur lit les instructions de haut en bas (comme d'habitude).

2. Puis, une fois arrivé à la fin de la boucle, il repart à la première instruction.

3. Il recommence alors à lire les instructions de haut en bas...

4. ... et il repart au début de la boucle :

Il existe 3 types de boucles à connaître :

1. while

2. do ... while

3. for

Faites une boucle while

Cette boucle s'utilise comme ceci :

while (condition)
{
    /* Instructions à répéter */
}

Tout ce qui est entre accolades sera répété tant que la condition est vérifiée.

Essayons de faire ce que j'ai dit plus tôt : on redemande le nombre d'enfants à l'utilisateur tant que celui-ci est inférieur à 0. Ce genre de boucle permet de s'assurer que l'utilisateur rentre un nombre correct :

int main()
{
    int nbEnfants(-1); // Nombre négatif pour pouvoir entrer dans la boucle

    while (nbEnfants < 0)
    {
        cout << "Combien d'enfants avez-vous ?" << endl;
        cin >> nbEnfants;
    }

    cout << "Merci d'avoir indique un nombre d'enfants correct. Vous en avez " << nbEnfants << endl;

    return 0;
}

Voici un exemple d'utilisation de ce programme :

Combien d'enfants avez-vous ?
-3
Combien d'enfants avez-vous ?
-5
Combien d'enfants avez-vous ?
2
Merci d'avoir indique un nombre d'enfants correct. Vous en avez 2

Tant que vous saisissez un nombre négatif, la boucle recommence. En effet, elle teste while (nbEnfants < 0)  , c'est-à-dire "Tant que le nombre d'enfants est inférieur à 0". Dès que le nombre devient supérieur ou égal à 0, la boucle s'arrête et le programme continue après l'accolade fermante.

Nous allons voir dans la vidéo suivante comment créer votre première boucle  while en faisant attention à ne pas tomber dans le piège de la boucle infinie : 

Faites une boucle do ... while

Cette boucle est très similaire à la précédente... La différence c'est que la condition n'est testée qu'à la fin. Cela signifie que le contenu de la boucle sera toujours lu au moins une fois.

Cette boucle prend la forme suivante :

do
{
    /* Instructions */
} while (condition);

Reprenons le code précédent et utilisons cette fois un do ... while  :

int main()
{
    int nbEnfants(0);

    do
    {
        cout << "Combien d'enfants avez-vous ?" << endl;
        cin >> nbEnfants;
    } while (nbEnfants < 0);

    cout << "Merci d'avoir indique un nombre d'enfants correct. Vous en avez " << nbEnfants << endl;

    return 0;
}

Le principe est le même, le programme a le même comportement.

Le grand intérêt de do ... while  , c'est qu'on s'assure que la boucle sera lue au moins une fois.

D'ailleurs, il n'est donc pas nécessaire d'initialiser nbEnfants à -1 (c'est le principal avantage que procure cette solution). En effet, le nombre d'enfants est initialisé ici à 0 (comme on a l'habitude de faire) et, comme la condition n'est testée qu'après le premier passage de la boucle, les instructions sont bien lues au moins une fois.

La vidéo suivante montre la différence entre la boucle while  et la boucle do...while   ;  effectivement, la boucle do...while  utilise le même principe que la boucle while  , mais lance au moins la première itération. 

Faites une boucle for

Ce type de boucle, que l'on retrouve fréquemment, permet de condenser :

• une initialisation ;

• une condition ;

• une incrémentation.

Voici sa forme :

for (initialisation ; condition ; incrementation)
{

}

Regardons un exemple concret qui affiche des nombres de 0 à 9 :

int main()
{
    int compteur(0);

    for (compteur = 0 ; compteur < 10 ; compteur++)
    {
        cout << compteur << endl;
    }

    return 0;
}

Ce code affiche :

0
1
2
3
4
5
6
7
8
9

On retrouve sur la ligne du for les 3 instructions que je vous ai indiquées :

• Une initialisation ( compteur = 0  ) : la variable compteur est mise à 0 au tout début de la boucle. Notez que cela avait été fait à la ligne immédiatement au-dessus, ce n'était donc pas vraiment nécessaire ici.

• Une condition ( compteur < 10  ) : on vérifie que la variable compteur est inférieure à 10 à chaque nouveau tour de boucle.

• Une incrémentation ( compteur++  ) : à chaque tour de boucle, on ajoute 1 à la variable compteur  ! Voilà pourquoi on voit s'afficher à l'écran des nombres de 0 à 9.

Notez qu'il est courant d'initialiser la variable directement à l'intérieur du for  , comme ceci :

int main()
{
    for (int compteur(0) ; compteur < 10 ; compteur++)
    {
        cout << compteur << endl;
    }

    return 0;
}

La variable n'existe alors que pendant la durée de la boucle for. C'est la forme la plus courante de cette boucle. On ne déclare la variable avant le for que si on en a besoin plus tard, ce qui est un cas assez rare.

Pour terminer ce chapitre, je vous propose un dernier screencast qui présente l’utilisation d’une boucle for, et notamment les erreurs à éviter :

En résumé

• Les boucles permettent de répéter les mêmes instructions plusieurs fois.

• On distingue trois types de boucles : while  , do... while et for  .

• La boucle for est généralement utilisée lorsqu'on sait combien de fois on souhaite répéter les instructions, tandis que while et do... while sont plutôt utilisées lorsqu'on souhaite répéter des instructions jusqu'à ce qu'une condition spécifique soit vérifiée.

Je suis sûr que les structures de contrôle n’ont plus de secret pour vous. Avant de passer à la suite, voici un quiz pour tester vos connaissances, bonne chance !