L'un des plus grands atouts d'un ordinateur est sa capacité à exécuter des millions de fois la même séquence d'instructions avec une précision infaillible et à une vitesse vertigineuse. Pour automatiser ces répétitions sans dupliquer inutilement notre code source, le langage C met à disposition trois structures itératives : while, do ... while et for.

Cette leçon vous apprend à choisir la boucle adaptée à chaque situation et à éviter le piège fatal de la boucle infinie.

---

1. La boucle while (Test préalable)

La boucle while (tant que) évalue sa condition avant chaque tour. Si la condition est vraie (true), le bloc d'instructions est exécuté. Si elle est fausse dès le départ, la boucle n'est jamais exécutée.

flowchart TD
    Start[Entrée dans la boucle] --> Condition{La condition est-elle VRAIE ?}
    Condition -- Oui --> Corps[Exécuter le bloc d'instructions\n+ Modifier la variable de contrôle]
    Corps --> Condition
    Condition -- Non --> Fin[Sortir de la boucle et continuer]

Syntaxe et exemple

Compte à rebours avec while

#include <stdio.h>

int main(void)
{
    int compte = 5;

    while (compte > 0)
    {
        printf("%d... ", compte);
        compte--; // TRÈS IMPORTANT : modifier la condition d'arrêt !
    }

    printf("Décollage !\n");
    return 0;
}

[!WARNING] Si vous oubliez de modifier la variable de contrôle à l'intérieur du bloc (comme l'instruction compte--), la condition restera perpétuellement vraie et votre programme tournera en boucle infinie, saturant votre processeur.

---

2. La boucle do ... while (Test postérieur)

La boucle do ... while (faire ... tant que) évalue sa condition après l'exécution du bloc d'instructions.

Elle garantit ainsi que le bloc sera exécuté au moins une fois, quelle que soit la condition initiale. C'est l'outil par excellence pour valider la saisie utilisateur au clavier.

flowchart TD
    Start[Entrée dans la boucle] --> Corps[Exécuter le bloc d'instructions au moins 1 fois]
    Corps --> Condition{La condition de reprise est-elle VRAIE ?}
    Condition -- Oui --> Corps
    Condition -- Non --> Fin[Sortir de la boucle]

Syntaxe et exemple de validation de saisie

Contrôle de saisie d'une note académique

#include <stdio.h>

int main(void)
{
    float note = -1.0f;

    // Répéter la demande tant que la note n'est pas comprise entre 0 et 20
    do
    {
        printf("Veuillez saisir une note valide (entre 0.0 et 20.0) : ");
        scanf("%f", &note);

        if (note < 0.0f || note > 20.0f)
        {
            printf("Erreur : La note doit etre comprise entre 0 et 20 !\n");
        }
    } while (note < 0.0f || note > 20.0f); // N'oubliez pas le point-virgule final !

    printf("Merci ! Note enregistree : %.2f/20\n", note);
    return 0;
}

---

3. La boucle for (Boucle bornée déterministe)

La boucle for (pour) est idéale lorsque vous connaissez à l'avance le nombre d'itérations à effectuer (par exemple pour parcourir un tableau ou compter de 1 à 100). Elle rassemble en une seule ligne compacte : 1. L'initialisation du compteur. 2. La condition de maintien. 3. L'incrémentation après chaque tour.

\[\text{for ( } \underbrace{\text{initialisation}}_{\text{exécutée 1 fois}} \text{ ; } \underbrace{\text{condition}}_{\text{testée avant chaque tour}} \text{ ; } \underbrace{\text{incrémentation}}_{\text{exécutée après chaque tour}} \text{ )}\]

Syntaxe et exemple : Table de multiplication

Table de multiplication avec for

#include <stdio.h>

int main(void)
{
    int nombre = 7;

    printf("--- TABLE DE MULTIPLICATION DE %d ---\n", nombre);
    for (int i = 1; i <= 10; i++)
    {
        printf("%d x %2d = %2d\n", nombre, i, nombre * i);
    }

    return 0;
}

---

4. Rupture et saut de boucle : break et continue

Le langage C fournit deux mots-clés pour modifier le flux normal d'itération :

Sortie immédiate avec break

L'instruction break interrompt prématurément la boucle et en sort immédiatement (souvent utilisée lors d'une recherche dès qu'un élément est trouvé) :

for (int i = 1; i <= 100; i++)
{
    if (i == 42)
    {
        printf("Element 42 trouve ! Arret de la recherche.\n");
        break; // Sort immédiatement de la boucle for
    }
}

Saut d'itération avec continue

L'instruction continue arrête le tour de boucle courant et passe directement à l'itération suivante sans exécuter le reste du bloc :

// Affiche uniquement les nombres impairs entre 1 et 10
for (int i = 1; i <= 10; i++)
{
    if (i % 2 == 0)
    {
        continue; // Ignore les nombres pairs
    }
    printf("%d ", i); // Affiche : 1 3 5 7 9
}

---

5. Tableau comparatif : Quelle boucle choisir ?

Boucle	Évaluation de la condition	Nombre minimum d'itérations	Cas d'usage type
for	Au début	0	Le nombre de tours est connu à l'avance (compteurs, parcours de tableaux).
while	Au début	0	La fin dépend d'un événement dynamique sans nombre de tours prévisible.
do ... while	À la fin	1	Le traitement doit s'exécuter au moins une fois (menus interactifs, contrôle de saisie).

---

6. Mise en pratique : Calcul de la factorielle (\(n!\))

Énoncé : Écrivez un programme qui demande à l'utilisateur de saisir un entier positif \(n\) (\(0 \le n \le 12\)) et calcule sa factorielle définie par : $\(n! = 1 \times 2 \times 3 \times \dots \times n \quad \text{avec} \quad 0! = 1\)$

??? tip "Solution complète"

#include <stdio.h>

int main(void)
{
    int n = 0;

    // Validation de saisie avec do...while
    do
    {
        printf("Entrez un entier positif n (entre 0 et 12) : ");
        scanf("%d", &n);
    } while (n < 0 || n > 12);

    long long factorielle = 1;

    // Calcul du produit avec la boucle for
    for (int i = 1; i <= n; i++)
    {
        factorielle *= i;
    }

    printf("La factorielle de %d (%d!) vaut : %lld\n", n, n, factorielle);
    return 0;
}

---

Vous maîtrisez désormais les instructions élémentaires du C. Rassemblons toutes ces compétences dans la section d'applications pratiques qui clôture cette première partie.

Partagez sur les réseaux sociaux

Commentaires