Boucles en C++ : for, while, do-while

En programmation, les boucles permettent de répéter une opération plusieurs fois. En C++, les structures de boucle les plus courantes sont for, while et do-while. Les boucles sont utilisées pour des tâches répétitives telles que parcourir des tableaux, effectuer des calculs ou lire les entrées de l’utilisateur.

1. La boucle for

La boucle for est la plus utilisée lorsque le nombre de répétitions est connu à l’avance. Elle se compose de trois parties : initialisation, condition et incrément/décrément.

for (initialisation; condition; incrément) {
    // Instructions à répéter
}

Exemple :

#include <iostream>
using namespace std;

int main() {
    for (int i = 1; i <= 5; i++) {
        cout << "Nombre : " << i << endl;
    }
    return 0;
}

Sortie :

Nombre : 1
Nombre : 2
Nombre : 3
Nombre : 4
Nombre : 5

2. La boucle while

La boucle while s’exécute tant que la condition est vraie. La condition est vérifiée au début de chaque itération ; si elle est fausse dès le départ, la boucle ne s’exécute pas.

int nombre = 1;

while (nombre <= 5) {
    cout << "Nombre : " << nombre << endl;
    nombre++;
}

Cet exemple produit le même résultat que la boucle for, mais avec une structure plus flexible. Elle est souvent utilisée lorsque le nombre d’itérations n’est pas connu à l’avance (par exemple lors de la saisie utilisateur).

3. La boucle do-while

Dans une boucle do-while, la condition est vérifiée à la fin, de sorte que le bloc s’exécute au moins une fois.

int nombre = 1;

do {
    cout << "Nombre : " << nombre << endl;
    nombre++;
} while (nombre <= 5);

La sortie affiche encore les nombres de 1 à 5. Comme la condition est vérifiée à la fin, la première itération s’exécute toujours, quelle que soit la condition.

4. Boucles infinies

Si la condition d’une boucle n’est jamais false, la boucle s’exécute indéfiniment. Les boucles infinies sont généralement interrompues à l’aide de break ou return.

while (true) {
    cout << "Ce message s’affiche en continu." << endl;
    break; // Arrête la boucle infinie
}

Remarque : Les boucles infinies doivent être utilisées avec précaution, sinon le programme ne se termine jamais.

5. Les mots-clés break et continue

Deux instructions spéciales sont utilisées pour modifier le contrôle d’une boucle :

• break : met fin complètement à la boucle.
• continue : saute l’itération actuelle et passe à la suivante.

for (int i = 1; i <= 10; i++) {
    if (i == 5)
        continue; // Sauter 5
    if (i == 8)
        break;    // Arrêter la boucle à 8
    cout << i << " ";
}

Sortie :

1 2 3 4 6 7

6. Boucles imbriquées (Nested Loops)

Une boucle peut être définie à l’intérieur d’une autre. Cette structure est particulièrement utile pour manipuler des tableaux, des matrices ou des données multidimensionnelles.

#include <iostream>
using namespace std;

int main() {
    for (int i = 1; i <= 3; i++) {
        for (int j = 1; j <= 4; j++) {
            cout << "(" << i << "," << j << ") ";
        }
        cout << endl;
    }
    return 0;
}

Sortie :

(1,1) (1,2) (1,3) (1,4)
(2,1) (2,2) (2,3) (2,4)
(3,1) (3,2) (3,3) (3,4)

Ici, la boucle externe (i) représente les lignes, et la boucle interne (j) représente les colonnes. Cette structure est très utile lors du travail avec des tableaux multidimensionnels.

7. Exemple pratique : Table de multiplication

L’un des exemples les plus connus d’utilisation de boucles imbriquées est la table de multiplication.

#include <iostream>
using namespace std;

int main() {
    for (int i = 1; i <= 5; i++) {
        for (int j = 1; j <= 5; j++) {
            cout.width(4);
            cout << i * j;
        }
        cout << endl;
    }
    return 0;
}

Sortie :

   1   2   3   4   5
   2   4   6   8  10
   3   6   9  12  15
   4   8  12  16  20
   5  10  15  20  25

8. while et do-while avec saisie utilisateur

Les boucles peuvent également être utilisées pour demander à l’utilisateur une entrée jusqu’à ce qu’une valeur valide soit saisie.

#include <iostream>
using namespace std;

int main() {
    int nombre;
    do {
        cout << "Entrez un nombre positif : ";
        cin >> nombre;
    } while (nombre <= 0);

    cout << "Nombre saisi : " << nombre << endl;
    return 0;
}

Si l’utilisateur saisit un nombre négatif, la boucle se répète ; lorsqu’un nombre positif est saisi, elle se termine.

9. TL;DR

Articles connexes