Les boucles en C++ (C++17 et C++20)

Les boucles en C++

Types de conditions de boucle

Une condition de boucle peut prendre différentes formes :

• Exécuter une boucle un nombre donné de fois
• Exécuter une boucle jusqu'à ce qu'une valeur donnée dépasse une autre valeur
• Exécuter une boucle jusqu'à ce qu'un caractère particulier soit saisi au clavier
• Exécuter une boucle pour chaque élément d'une collection d'éléments

Les quatre variétés de boucles en C++

1. La boucle for

for (initialisation; condition; itération) {
    // corps de la boucle
}
// instructions suivantes

Vous pouvez omettre tout ou partie des expressions, mais vous devez toujours inclure les points-virgules.

Fonctionnement

1. L'expression d'initialisation est évaluée une seule fois, au début de la boucle.
2. La condition est vérifiée. Si elle est vraie, le corps est exécuté. Si elle est fausse, la boucle se termine.
3. Après chaque exécution du corps, l'expression d'itération est évaluée.
4. Retour à l'étape 2.

Exemple 1 : Boucle for classique

for (int i = 0; i < 10; i++) {
    cout << i;
}

Exemple 2 : Accolades optionnelles

for (int i = 0; i < 10; i++)
    cout << i;  // une seule instruction, accolades facultatives

Portée de la variable de contrôle

Une boucle définit une portée. Les variables déclarées dans l'initialisation sont locales à la boucle.

Exemple 3 : Variable locale à la boucle

for (int i = 0; i < 10; i++) {
    cout << i;
}
// cout << i;  // ERREUR : i n'existe plus ici

Exemple 4 : Variable accessible après la boucle

int i;
for (i = 0; i < 10; i++) {
    cout << i;
}
cout << "\nValeur finale de i : " << i;  // 10

Variantes de la boucle for

Exemple 5 : Utilisation de l'opérateur virgule

for (int k = 0, m = 0; k < 5; ++k, m--) {
    cout << k + m << " ";
}
// Affiche : 0 0 0 0 0 (car m décroît en même temps que k croît)

L'opérateur virgule combine deux expressions en une seule. Partout où vous pouvez mettre une expression, vous pouvez mettre une série d'expressions séparées par des virgules.

Exemple 6 : Omission de paramètres

// Boucle infinie
for (;;) {
    // attention : ne s'arrête jamais sans break
}

// Incrémentation dans le corps
for (int i = 0; i < 10; ) {
    cout << i++;
}

// Variable définie avant la boucle
int cpt = 0;
for (; cpt < 10; ++cpt) {
    // ...
}
// cpt est accessible ici

Boucle for avec des valeurs à virgule flottante

Vous pouvez utiliser n'importe quel type pour contrôler une boucle, y compris des nombres à virgule flottante.

Exemple 7 : Boucle avec double

#include <iostream>

using namespace std;

int main(void){
    for (double r {2.5}; r <= 20.0; r += 2.5) {
        cout << r << '\t';
    }
    return 0;
}

2.5     5       7.5     10      12.5    15      17.5    20

2. La boucle for basée sur les collections (C++11 et ultérieur)

for (coll_déclaration : coll_expression) 
    corps de la boucle;

Exemple 8 : Parcours d'un tableau

#include <iostream>

using namespace std;

int main(void){
    int T[4] = {1, 7, 13, 17};
    for (int elem : T) {
        cout << elem << '\t';
    }
    return 0;
}

1       7       13      17

Exemple 9 : Utilisation de auto

int T[4] = {1, 7, 13, 17};
for (auto elem : T) {   // auto déduit le type (int)
    cout << elem << '\t';
}

Exemple 10 : Modification des éléments avec référence

int T[4] = {1, 7, 13, 17};

// Modification avec référence
for (auto &elem : T) {
    elem = 5;
}

// Affichage
for (auto elem : T) {
    cout << elem << '\t';  // 5 5 5 5
}

Nouveauté C++20 : initialisation dans la boucle for

for ([initialisation;] coll_déclaration : coll_expression) 
    corps de la boucle;

Exemple 11 : Initialisation dans la boucle (C++20)

for (int T[4] = {1, 7, 13, 17}; int elem : T) {
    cout << elem << '\t';
}

3. La boucle while

while (condition) {
    // corps de la boucle
}
// instructions après la boucle

Exemple 12 : Boucle while classique

int i = 0;
while (i < 10) {
    cout << i << '\t';
    i++;
}

Équivalence for / while

Toute boucle for peut être écrite comme une boucle while équivalente :

// Boucle for
for (initialisation; condition; itération) 
    corps

// Équivalent en while
{
    initialisation; 
    while (condition) {
        corps
        itération; 
    }
}

Les accolades supplémentaires autour du while créent une portée simulant celle de la boucle for.

4. La boucle do-while

do {
    // corps de la boucle...
} while (condition);  // <-- point-virgule obligatoire !

Exemple 13 : Saisie de notes jusqu'à demande d'arrêt

#include <iostream>

using namespace std;

int main(void){
    char rep {};
    int nb {};
    double note {};
    double somme {};

    do {
        cout << "Saisir une note : ";
        cin >> note;
        somme += note;
        ++nb;

        cout << "Voulez-vous en saisir une autre ? (o/n) : ";
        cin >> rep;
    } while (rep == 'o');

    cout << "La moyenne est : " << somme/nb << '\n';
    
    return 0;
}

Saisir une note : 12
Voulez-vous en saisir une autre ? (o/n) : o
Saisir une note : 14
Voulez-vous en saisir une autre ? (o/n) : o
Saisir une note : 10
Voulez-vous en saisir une autre ? (o/n) : o
Saisir une note : 17
Voulez-vous en saisir une autre ? (o/n) : n
La moyenne est : 13.25

Ce programme est idéal pour ce type de situation car on veut toujours saisir au moins une note.

Instructions break et continue

continue

L'instruction continue permet d'ignorer le reste de l'itération en cours et de passer à la suivante.

continue;  // passe à l'itération suivante

Exemple 14 : Utilisation de continue

#include <iostream>

using namespace std;

int main(void){
    for(int i=0 ; i < 5 ; i++){
        if(i==3){
            continue;  // saute l'itération i=3
        }
        cout << "Itération : " << i << '\n';
    }
    return 0;
}

Itération : 0
Itération : 1
Itération : 2
Itération : 4

L'itération i=3 est complètement ignorée.

break

L'instruction break met fin immédiatement à la boucle, sans exécuter le reste des itérations.

break;  // termine la boucle immédiatement

Exemple 15 : Utilisation de break

#include <iostream>

using namespace std;

int main(void){
    for(int i=0; i < 5; i++){
        if(i==3){
            break;  // arrête la boucle quand i atteint 3
        }
        cout << "Itération : " << i << '\n';
    }
    return 0;
}

Itération : 0
Itération : 1
Itération : 2

Boucles imbriquées

Récapitulatif des boucles