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 :
forwhiledo-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 = 0et s’arrête lorsqueidevient égal à 5. À chaque itération, la valeur deiest 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
compteurest inférieur à 5, la boucle s’exécute. À chaque itération,compteurest 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 variablej. À 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
iatteint 5, grâce à l’instructionbreak.
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
iest pair,continueforce 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 < 5pour é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
breaketcontinue: 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
forlorsque 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
forparcourt les nombres de 1 à 10. - La condition
i % 2 == 0vérifie si le nombre est pair. Si c’est le cas, le nombre est ajouté à la variablesomme. - 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
maxest initialisée avec la première valeur du tableau (tableau[0]). - La boucle
forparcourt le tableau à partir du deuxième élément (i = 1) et compare chaque élément avecmax. Si un élément est plus grand,maxest 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
whilepour multiplier successivement les entiers de 1 àn. - La variable
factorielleaccumule le produit de chaque entier, et la valeur finale est la factorielle den. - Si
n = 5, la sortie seraLa factorielle de 5 est 120(car5! = 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
forparcourt le tableau jusqu’à son milieu, en échangeant les éléments symétriques de part et d’autre du tableau. - La variable temporaire
tempest 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.
Autres articles
