Boucles en C dans la Pratique

Les boucles en langage C permettent de répéter l’exécution d’un bloc de code tant qu’une condition est vraie ou pour un nombre déterminé d’itérations. Elles sont essentielles pour de nombreuses tâches comme le parcours de tableaux, l’exécution répétée d’instructions ou encore la gestion des structures de données. Dans ce guide, nous allons passer en revue les types de boucles disponibles en C et les meilleures pratiques pour les utiliser efficacement.

1. Types de Boucles en C

En C, il existe trois types de boucles principales :

for
while
do-while

1.1. Boucle `for`

La boucle for est généralement utilisée lorsque le nombre d’itérations est connu à l’avance. Elle permet d’initialiser une variable de contrôle, de spécifier une condition et d’incrémenter ou décrémenter cette variable à chaque itération.

Syntaxe :

for (initialisation; condition; incrémentation) {
    // Instructions
}

Initialisation : se produit une seule fois, avant le début de la boucle.
Condition : vérifiée avant chaque itération. Si la condition est fausse, la boucle s’arrête.
Incrémentation : modifie la variable de contrôle après chaque itération.

Exemple :

#include <stdio.h>

int main() {
    int i;

    for (i = 0; i < 5; i++) {
        printf("Itération %d\n", i);
    }

    return 0;
}

Explication :

La boucle commence à i = 0 et s’arrête lorsque i devient égal à 5. À chaque itération, la valeur de i est affichée et incrémentée de 1.

1.2. Boucle `while`

La boucle while est utilisée lorsque vous ne savez pas à l’avance combien de fois vous devrez répéter l’exécution du bloc de code, mais vous avez une condition qui décide de la continuation de la boucle.

Syntaxe :

while (condition) {
    // Instructions
}

La condition est vérifiée avant chaque itération. Si elle est fausse dès le début, la boucle peut ne jamais s’exécuter.

Exemple :

#include <stdio.h>

int main() {
    int compteur = 0;

    while (compteur < 5) {
        printf("Compteur = %d\n", compteur);
        compteur++;
    }

    return 0;
}

Explication :

Tant que compteur est inférieur à 5, la boucle s’exécute. À chaque itération, compteur est incrémenté de 1.

1.3. Boucle `do-while`

La boucle do-while est similaire à la boucle while, mais avec une différence majeure : le bloc d’instructions s’exécute au moins une fois, car la condition est vérifiée après l’exécution du bloc.

Syntaxe :

do {
    // Instructions
} while (condition);

Exemple :

#include <stdio.h>

int main() {
    int compteur = 0;

    do {
        printf("Compteur = %d\n", compteur);
        compteur++;
    } while (compteur < 5);

    return 0;
}

Explication :

La boucle commence par exécuter le bloc d’instructions, puis elle vérifie la condition après chaque itération. La boucle s’exécute au moins une fois, même si la condition est fausse dès le départ.

2. Boucles Imbriquées

Il est possible d’imbriquer des boucles en C, c’est-à-dire de mettre une boucle à l’intérieur d’une autre boucle. Cela est souvent utilisé pour parcourir des structures bidimensionnelles comme des matrices.

Exemple :

#include <stdio.h>

int main() {
    int i, j;

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

    return 0;
}

Explication :

Ici, la boucle extérieure contrôle la variable i, et la boucle intérieure contrôle la variable j. À chaque itération de la boucle extérieure, la boucle intérieure s’exécute complètement.

3. Utilisation de `break` et `continue` dans les Boucles

3.1. L’instruction `break`

L’instruction break permet de sortir immédiatement de la boucle, même si la condition n’est pas encore fausse. Cela peut être utile si vous souhaitez arrêter une boucle lorsqu’une certaine condition est remplie.

Exemple :

#include <stdio.h>

int main() {
    int i;

    for (i = 0; i < 10; i++) {
        if (i == 5) {
            break;  // Sort de la boucle si i est égal à 5
        }
        printf("i = %d\n", i);
    }

    return 0;
}

Explication :

La boucle s’arrête lorsque i atteint 5, grâce à l’instruction break.

3.2. L’instruction `continue`

L’instruction continue permet de passer immédiatement à la prochaine itération de la boucle, en ignorant les instructions restantes du bloc courant.

Exemple :

#include <stdio.h>

int main() {
    int i;

    for (i = 0; i < 10; i++) {
        if (i % 2 == 0) {
            continue;  // Saute à l'itération suivante si i est pair
        }
        printf("i = %d\n", i);
    }

    return 0;
}

Explication :

Lorsque i est pair, continue force le saut à la prochaine itération. Seuls les nombres impairs sont affichés.

4. Erreurs courantes avec les boucles

4.1. Boucles infinies

Une boucle infinie se produit lorsque la condition de terminaison d’une boucle n’est jamais remplie. Cela peut être dû à une erreur dans l’incrémentation ou à une condition toujours vraie.

Exemple :

#include <stdio.h>

int main() {
    int i = 0;

    while (i < 5) {
        printf("i = %d\n", i);
        // Erreur : i n'est jamais incrémenté, boucle infinie
    }

    return 0;
}

Solution :

Il faut ajouter i++ dans la boucle pour qu’elle se termine.

4.2. Accès à des indices hors limites

Lorsqu’une boucle est utilisée pour parcourir un tableau, il est important de ne pas dépasser les limites de ce tableau. Cela peut provoquer un comportement indéfini.

Exemple :

#include <stdio.h>

int main() {
    int tableau[5] = {1, 2, 3, 4, 5};

    for (int i = 0; i <= 5; i++) {  // Erreur : i <= 5 dépasse les limites du tableau
        printf("%d\n", tableau[i]);
    }

    return 0;
}

Solution :

Utiliser la condition correcte i < 5 pour éviter d’accéder à un index hors limites.

5. Meilleures pratiques pour utiliser les boucles en C

S’assurer que la condition de sortie de la boucle est correcte : Assurez-vous que la condition qui termine la boucle sera atteinte. Cela évite les boucles infinies.
Limiter l’utilisation de break et continue : Ces instructions peuvent rendre le flux de la boucle difficile à suivre. Utilisez-les avec parcimonie.
Utiliser des boucles imbriquées de manière raisonnable : Les boucles imbriquées peuvent augmenter la complexité temporelle (O(n²) ou plus). Essayez de réduire le nombre de boucles imbriquées si possible.
Préférer la boucle for lorsque le nombre d’itérations est connu : Cela rend le code plus lisible et évite les erreurs d’incrémentation.

6. Exercice corrigé : Somme des nombres pairs

Énoncé :

Écrivez un programme qui calcule la somme des nombres pairs compris entre 1 et 10 en utilisant une boucle.

Solution :

#include <stdio.h>

int main() {
    int somme = 0;

    for (int i = 1; i <= 10; i++) {
        if (i % 2 == 0) {
            somme += i;  // Ajouter les nombres pairs à la somme
        }
    }

    printf("La somme des nombres pairs entre 1 et 10 est : %d\n", somme);

    return 0;
}

Explication :

La boucle for parcourt les nombres de 1 à 10.
La condition i % 2 == 0 vérifie si le nombre est pair. Si c’est le cas, le nombre est ajouté à la variable somme.
Le programme affiche ensuite la somme totale des nombres pairs entre 1 et 10, qui est 30 (2 + 4 + 6 + 8 + 10 = 30).

7. Exercice corrigé : Trouver le plus grand nombre dans un tableau

Énoncé :

Écrivez un programme qui trouve et affiche le plus grand nombre dans un tableau d’entiers donné.

Solution :

#include <stdio.h>

int main() {
    int tableau[] = {5, 12, 8, 20, 7};
    int taille = sizeof(tableau) / sizeof(tableau[0]);  // Calcul de la taille du tableau
    int max = tableau[0];  // On suppose que le premier élément est le plus grand

    for (int i = 1; i < taille; i++) {
        if (tableau[i] > max) {
            max = tableau[i];  // Mettre à jour le plus grand nombre
        }
    }

    printf("Le plus grand nombre est : %d\n", max);

    return 0;
}

Explication :

La variable max est initialisée avec la première valeur du tableau (tableau[0]).
La boucle for parcourt le tableau à partir du deuxième élément (i = 1) et compare chaque élément avec max. Si un élément est plus grand, max est mis à jour.
Après avoir parcouru tout le tableau, le programme affiche le plus grand nombre, qui est 20 dans cet exemple.

8. Exercice corrigé : Calculer la factorielle d’un nombre

Énoncé :

Écrivez un programme qui calcule la factorielle d’un nombre entier donné en utilisant une boucle while.

Solution :

#include <stdio.h>

int main() {
    int n, i = 1;
    unsigned long long factorielle = 1;

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

    while (i <= n) {
        factorielle *= i;  // Multiplier par i à chaque itération
        i++;
    }

    printf("La factorielle de %d est %llu\n", n, factorielle);

    return 0;
}

Explication :

Le programme utilise une boucle while pour multiplier successivement les entiers de 1 à n.
La variable factorielle accumule le produit de chaque entier, et la valeur finale est la factorielle de n.
Si n = 5, la sortie sera La factorielle de 5 est 120 (car 5! = 5 * 4 * 3 * 2 * 1 = 120).

9. Exercice corrigé : Inverser un tableau avec une boucle `for`

Énoncé :

Écrivez un programme qui inverse les éléments d’un tableau d’entiers en place.

Solution :

#include <stdio.h>

int main() {
    int tableau[] = {1, 2, 3, 4, 5};
    int taille = sizeof(tableau) / sizeof(tableau[0]);
    int temp;

    for (int i = 0; i < taille / 2; i++) {
        temp = tableau[i];  // Sauvegarder la valeur de tableau[i]
        tableau[i] = tableau[taille - 1 - i];  // Copier l'élément symétrique
        tableau[taille - 1 - i] = temp;  // Placer la valeur sauvegardée à l'autre extrémité
    }

    // Affichage du tableau inversé
    printf("Tableau inversé : ");
    for (int i = 0; i < taille; i++) {
        printf("%d ", tableau[i]);
    }
    printf("\n");

    return 0;
}

Explication :

La boucle for parcourt le tableau jusqu’à son milieu, en échangeant les éléments symétriques de part et d’autre du tableau.
La variable temporaire temp est utilisée pour sauvegarder l’élément avant l’échange.
Le tableau {1, 2, 3, 4, 5} devient {5, 4, 3, 2, 1} après inversion.

Les boucles en C sont des outils puissants pour gérer des tâches répétitives. Que ce soit pour parcourir des tableaux, effectuer des calculs itératifs ou manipuler des structures de données, les boucles for, while et do-while permettent de simplifier la programmation. Ce guide vous a présenté les différents types de boucles, leurs applications pratiques, ainsi que des exemples concrets pour maîtriser leur usage dans des situations variées.

Pour éviter les erreurs courantes telles que les boucles infinies ou l’accès hors limites des tableaux, il est essentiel de bien structurer vos boucles et de vérifier les conditions de sortie. Les exercices corrigés proposés vous aideront à appliquer ces concepts de manière pratique.