les boucles en c

Structures itératives en C

Définition — Boucle (structure itérative) Une boucle permet de répéter un bloc d'instructions tant qu'une condition reste vraie. Elle se compose toujours de trois éléments : une initialisation (point de départ), une condition (critère de continuation) et une mise à jour (évolution vers la sortie).

Boucle	Type	Condition testée	Garanti au moins 1 itération	Usage recommandé
`for`	Entrée contrôlée	Avant le corps	Non	Nombre d'itérations connu
`while`	Entrée contrôlée	Avant le corps	Non	Condition de fin connue, nb itérations inconnu
`do-while`	Sortie contrôlée	Après le corps	Oui	Corps exécuté au moins une fois (menu, saisie)

1. Boucle `for`

for — Boucle à compteur La boucle for regroupe les trois composantes sur une seule ligne : initialisation, condition et mise à jour. Elle est idéale lorsque le nombre d'itérations est connu à l'avance.

Syntaxe C

for (initialisation ; condition ; mise_a_jour) {
    /* bloc répété tant que condition est vraie */
}

Déroulement d'un for :

Initialisation — exécutée une seule fois au départ
Condition — évaluée avant chaque itération ; si fausse → sortie
Corps — exécuté si la condition est vraie
Mise à jour — exécutée après chaque corps, puis retour en 2

Exemple n°1 — Afficher les entiers de 0 à 4

#include <stdio.h>

int main(void)
{
    int i;
    for (i = 0 ; i < 5 ; i++) {
        printf("i = %d\n", i);
    }
    return 0;
}

Sortie

i = 0
i = 1
i = 2
i = 3
i = 4

Exemple n°2 — Somme des N premiers entiers

#include <stdio.h>

int main(void)
{
    int n, i, somme = 0;

    printf("Entrez N : ");
    scanf("%d", &n);

    for (i = 1 ; i <= n ; i++) {
        somme += i;
    }

    printf("Somme de 1 à %d = %d\n", n, somme);
    return 0;
}

Sortie (N = 5)

Entrez N : 5
Somme de 1 à 5 = 15

Exemple n°3 — Boucle for décroissante (compte à rebours)

#include <stdio.h>

int main(void)
{
    int i;
    for (i = 5 ; i >= 1 ; i--) {
        printf("%d...\n", i);
    }
    printf("Décollage !\n");
    return 0;
}

Sortie

5...
4...
3...
2...
1...
Décollage !

Astuce — Parties optionnelles du for Les trois parties du forsont optionnelles. On peut les omettre (les points-virgules restent obligatoires) :

int i = 0;
for ( ; i < 5 ; ) {    /* initialisation et mise à jour hors du for */
    printf("%d\n", i);
    i++;
}

for ( ; ; ) { }         /* boucle infinie */

2. Boucle `while`

while — Boucle à condition préalable La boucle while évalue la condition avant chaque itération. Si la condition est fausse dès le départ, le corps n'est jamais exécuté. Elle est adaptée quand le nombre d'itérations n'est pas connu à l'avance mais que la condition d'arrêt est connue.

Syntaxe C

initialisation;
while (condition) {
    /* corps de la boucle */
    mise_a_jour;
}

Exemple n°4 — Équivalent for avec while

#include <stdio.h>

int main(void)
{
    int i = 0;              /* initialisation */
    while (i < 5) {         /* condition      */
        printf("i = %d\n", i);
        i++;                /* mise à jour    */
    }
    return 0;
}

Sortie

i = 0
i = 1
i = 2
i = 3
i = 4

Exemple n°5 — Saisie jusqu'à un nombre positif

#include <stdio.h>

int main(void)
{
    int n;

    printf("Entrez un entier positif : ");
    scanf("%d", &n);

    while (n <= 0) {
        printf("Valeur invalide. Réessayez : ");
        scanf("%d", &n);
    }

    printf("Valeur acceptée : %d\n", n);
    return 0;
}

Sortie

Entrez un entier positif : -5
Valeur invalide. Réessayez : 0
Valeur invalide. Réessayez : 7
Valeur acceptée : 7

3. Boucle `do-while`

do-while — Boucle à condition finale La boucle do-while exécute le corps au moins une fois, puis évalue la condition. Si la condition est vraie, le corps est répété. Elle est adaptée aux menus interactifs et aux saisies validées.

Syntaxe C

initialisation;
do {
    /* corps de la boucle */
    mise_a_jour;
} while (condition);   /* ← point-virgule obligatoire */

Attention — Point-virgule après while Le point-virgule à la fin de } while (condition); est obligatoire. Son absence provoque une erreur de compilation.

Exemple n°6 — Compteur de 0 à 4 avec do-while

#include <stdio.h>

int main(void)
{
    int i = 0;
    do {
        printf("i = %d\n", i);
        i++;
    } while (i < 5);

    return 0;
}

Sortie

i = 0
i = 1
i = 2
i = 3
i = 4

Exemple n°7 — Menu interactif (cas d'usage typique)

#include <stdio.h>

int main(void)
{
    int choix;

    do {
        printf("\n--- Menu ---\n");
        printf("1. Option A\n");
        printf("2. Option B\n");
        printf("0. Quitter\n");
        printf("Votre choix : ");
        scanf("%d", &choix);

        switch (choix) {
            case 1: printf("Option A sélectionnée\n"); break;
            case 2: printf("Option B sélectionnée\n"); break;
            case 0: printf("Au revoir !\n");            break;
            default: printf("Choix invalide\n");
        }
    } while (choix != 0);

    return 0;
}

Sortie

--- Menu ---
1. Option A
2. Option B
0. Quitter
Votre choix : 1
Option A sélectionnée

--- Menu ---
...
Votre choix : 0
Au revoir !

4. Boucle infinie

Boucle infinie Une boucle infinie est une boucle dont la condition reste toujours vraie et qui ne s'arrête donc jamais d'elle-même. Elle est intentionnellement utilisée dans les serveurs, les systèmes embarqués et les jeux, avec un mécanisme de sortie explicite (break ou signal).

Syntaxe — 3 formes équivalentes C

/* for — forme idiomatique recommandée */
for ( ; ; ) {
    /* corps */
    if (condition_sortie) break;
}

/* while */
while (1) {
    /* corps */
    if (condition_sortie) break;
}

/* do-while */
do {
    /* corps */
} while (1);

Exemple n°8 — Saisie répétée jusqu'à la valeur sentinelle −1

#include <stdio.h>

int main(void)
{
    int val, somme = 0, nb = 0;

    printf("Saisir des entiers (-1 pour terminer) :\n");

    while (1) {
        scanf("%d", &val);
        if (val == -1) break;   /* condition de sortie */
        somme += val;
        nb++;
    }

    if (nb > 0)
        printf("Somme = %d | Moyenne = %.2f\n", somme, (float)somme / nb);
    else
        printf("Aucune valeur saisie.\n");

    return 0;
}

Sortie

Saisir des entiers (-1 pour terminer) :
4 7 3 -1
Somme = 14 | Moyenne = 4.67

Danger — Boucle infinie accidentelleLes causes les plus fréquentes de boucles infinies non intentionnelles sont l'oubli de la mise à jour du compteur et une condition qui ne peut jamais devenir fausse :

/* Boucle infinie — i non incrémenté */
int i = 0;
while (i < 5) {
    printf("%d\n", i);
    /* oubli de i++ */
}

/* Boucle infinie — condition toujours vraie */
for (int i = 0 ; i >= 0 ; i++) {
    printf("%d\n", i);  /* i augmente indéfiniment */
}

5. Boucles imbriquées

Une boucle imbriquée est une boucle placée à l'intérieur d'une autre boucle. Pour chaque itération de la boucle externe, la boucle interne s'exécute entièrement.

Exemple n°9 — Table de multiplication

#include <stdio.h>

int main(void)
{
    int i, j;

    for (i = 1 ; i <= 3 ; i++) {
        for (j = 1 ; j <= 3 ; j++) {
            printf("%4d", i * j);
        }
        printf("\n");
    }

    return 0;
}

Sortie

   1   2   3
   2   4   6
   3   6   9

Guide de choix

Quelle boucle choisir ?

Le nombre d'itérations est connu à l'avance (parcourir un tableau de N éléments, répéter N fois) → for
La condition d'arrêt est connue mais le nombre d'itérations ne l'est pas (lire jusqu'à EOF, attendre une valeur valide) → while
Le corps doit s'exécuter au moins une fois (menu, saisie validée, initialisation avant vérification) → do-while

Récapitulatif

Critère	`for`	`while`	`do-while`
Test de condition	Avant le corps	Avant le corps	Après le corps
Exécution minimale	0 fois	0 fois	1 fois
Nb d'itérations	Connu à l'avance	Inconnu (condition)	Inconnu (condition)
Init / mise à jour	Dans l'en-tête	Hors de la syntaxe	Hors de la syntaxe
Boucle infinie	`for(;;)`	`while(1)`	`do{...}while(1);`
Usage typique	Compteur, tableau	Lecture, attente	Menu, saisie validée

Précédent Instruction switch en C et C++

Suivant Instruction break et continue en langage C

Structures itératives en C

1. Boucle `for`

2. Boucle `while`

3. Boucle `do-while`

4. Boucle infinie

5. Boucles imbriquées

Guide de choix

Récapitulatif

Discussion (0)

Laisser un commentaire

Structures de données

Algorithmes

Programmation

Bases de données

CPGE

Modules informatique

les boucles en c

Structures itératives en C

1. Boucle for

2. Boucle while

3. Boucle do-while

4. Boucle infinie

5. Boucles imbriquées

Guide de choix

Récapitulatif

Discussion (0)

Laisser un commentaire

1. Boucle `for`

2. Boucle `while`

3. Boucle `do-while`