Présentation des boucles en C++

En C++, les boucles permettent d'exécuter de manière répétée un bloc de code sous certaines conditions. Elles sont essentielles pour automatiser les tâches itératives. On distingue trois types principaux : for, while, et do-while, ainsi que les boucles imbriquées pour des scénarios complexes.

Boucle for

La boucle for est idéale lorsque le nombre d'itérations est déterminé à l'avance. Elle combine initialisation, condition et mise à jour dans une seule ligne.

#include <iostream>
int main() {
    for (int compteur = 0; compteur < 10; compteur += 2) {
        std::cout << "Valeur paire: " << compteur << std::endl;
    }
    return 0;
}

Ce code affiche les nombres pairs de 0 à 8. La variable compteur commence à 0 et s'incrémente de 2 à chaque itération jusqu'à ce que la condition soit fausse.

Boucle while

La boucle while répète une opération tant qu'une condition reste vraie. La vérification se fait avant l'exécution du bloc de code.

#include <iostream>
int main() {
    int iteration = 5;
    while (iteration > 0) {
        std::cout << "Compte à rebours: " << iteration << std::endl;
        iteration--;
    }
    return 0;
}

Ici, la boucle décrémente iteration de 5 jusqu'à 1, affichant un compte à rebours. Si la condition initiale est fausse, le bloc ne s'exécute jamais.

Boucle do-while

Contrairement aux autres boucles, do-while garantit au moins une exécution du bloc, car la condition est évaluée après chaque itération.

#include <iostream>
int main() {
    int saisie = 0;
    do {
        std::cout << "Entrez un nombre positif: ";
        std::cin >> saisie;
    } while (saisie <= 0);
    std::cout << "Merci d'avoir entré: " << saisie << std::endl;
    return 0;
}

Cet exemple demande à l'utilisateur de saisir un nombre positif ; la boucle continue tant que la saisie est invalide.

Boucles imbriquées

Les boucles imbriquées permettent de gérer des structures de données multiples ou de créer des motifs. Elles peuvent combiner différents types de boucles.

#include <iostream>
int main() {
    for (int ligne = 1; ligne <= 4; ligne++) {
        int colonne = 1;
        while (colonne <= ligne) {
            std::cout << "* ";
            colonne++;
        }
        std::cout << std::endl;
    }
    return 0;
}

Ce code produit un triangle d'étoiles en utilisant une boucle for externe pour les lignes et une boucle while interne pour les colonnes. La logique interne modifie le nombre d'étoiles par ligne.

Points clés et bonnes pratiques

• Pour éviter les boucles infinies, assurez-vous que la condition évolue vers false ou utilisez break pour une sortie anticipée.
• L'instruction continue saute le reste de l'itération courante et passe à la suivante.
• Les boucles peuvent être combinées avec des tableaux ou des fonctions pour des traitemetns de données avancés.