# Erreurs avec des boucles Les boucles sont des structures de contrôle fondamentales en programmation, permettant d'exécuter un bloc d'instructions de manière répétée. Cependant, leur mauvaise conception ou implémentation est une source fréquente d'erreurs logiques et de bugs. Ce chapitre explore les erreurs les plus courantes associées aux boucles et comment les identifier et les prévenir. > [!video] Vidéo explicative > <iframe width="560" height="315" src="https://www.youtube.com/embed/2cIhKLqoUuc?si=KJU8gPsoEkKLawgx" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe> ## 1. Erreurs courantes avec les boucles ### 1.1. Erreurs de "un de trop / un de moins" > [!definition] Erreur de "un de trop / un de moins" > Une erreur de "un de trop / un de moins" se produit lorsqu'une boucle exécute un nombre d'itérations incorrect, soit une itération de trop, soit une itération de moins que prévu. Cela est souvent dû à une mauvaise gestion des bornes d'un intervalle ou des conditions d'arrêt. Ces erreurs sont particulièrement insidieuses car elles ne provoquent pas toujours un crash du programme, mais produisent des résultats incorrects. > [!example] Exemple > Supposons que nous voulions parcourir un tableau de taille $N$ (indices de $0$ à $N-1$). > > **Cas 1 : Une itération de trop (accès hors limites)** > ``` > POUR i DE 0 À N FAIRE // Devrait être N-1 ou < N > { > // Accès à tableau[i] > } > ``` > Si $N=5$, cette boucle ira de $i=0$ à $i=5$, soit 6 itérations. `tableau[5]` est hors limites. > > **Cas 2 : Une itération de moins** > ``` > POUR i DE 0 À N-2 FAIRE // Devrait être N-1 ou < N > { > // Accès à tableau[i] > } > ``` > Si $N=5$, cette boucle ira de $i=0$ à $i=3$, manquant l'élément `tableau[4]`. > [!tip] Prévention de ces erreurs > - **Vérifier les bornes** : Toujours tester les conditions aux limites (début et fin de l'itération). > - **Utiliser des conventions cohérentes** : Par exemple, boucler de $0$ à $N-1$ (inclusif) ou de $0$ à $N$ (exclusif). > - **Compter les éléments** : Pour un intervalle $[A, B]$ inclusif, il y a $B - A + 1$ éléments. Pour un intervalle $[A, B[$ (exclusif en $B$), il y a $B - A$ éléments. ### 1.2. Boucles infinies > [!definition] Boucle infinie > Une boucle infinie est une boucle qui ne se termine jamais car sa condition d'arrêt n'est jamais remplie ou sa variable de contrôle n'est pas mise à jour correctement, rendant la condition toujours vraie. Les boucles infinies consomment des ressources CPU et mémoire, et peuvent bloquer le programme. > [!example] Exemple de boucle infinie > **Cas 1 : Condition toujours vraie** > ``` > i = 0 > TANT QUE i < 10 FAIRE > { > // Instructions > // Oubli de l'incrémentation de i > } > ``` > Ici, `i` reste toujours $0$, donc `i < 10` est toujours vrai. > > **Cas 2 : Mise à jour incorrecte** > ``` > i = 0 > TANT QUE i != 10 FAIRE > { > // Instructions > i = i - 1 // i diminue au lieu d'augmenter vers 10 > } > ``` > Ici, `i` devient $-1, -2, \dots$ et ne sera jamais égal à $10$. > [!warning] Attention > Les boucles infinies sont une cause fréquente de blocage d'applications. Elles sont souvent dues à un oubli ou une erreur dans la mise à jour de la variable de contrôle ou de la condition d'arrêt. ### 1.3. Condition de boucle incorrecte > [!definition] Condition de boucle incorrecte > Une condition de boucle incorrecte est une expression logique qui ne reflète pas l'intention du programmeur, entraînant des itérations qui s'arrêtent trop tôt, trop tard, ou ne se lancent pas du tout. Cela peut être lié aux OBOE, mais aussi à des erreurs logiques plus complexes. > [!example] Exemple de condition incorrecte > Supposons que nous voulions lire des entrées tant que l'utilisateur n'entre pas "FIN". > ``` > entree = "" > TANT QUE entree == "FIN" FAIRE // Devrait être entree != "FIN" > { > LIRE entree > // Traiter entree > } > ``` > Cette boucle ne s'exécutera jamais si `entree` n'est pas "FIN" au départ. ## 2. Stratégies de débogage Pour identifier et corriger les erreurs de boucles : - **Tracé manuel** : Simulez l'exécution de la boucle sur papier avec des valeurs spécifiques pour les variables. Notez l'état des variables à chaque itération. - **Affichages intermédiaires (Print Statements)** : Insérez des instructions d'affichage (`AFFICHER`, `print`, `console.log`) à l'intérieur de la boucle pour observer les valeurs des variables de contrôle et des données traitées à chaque itération. - **Utilisation d'un débogueur** : Un débogueur permet de suspendre l'exécution du programme (points d'arrêt), d'exécuter le code pas à pas et d'inspecter l'état de toutes les variables. C'est un outil puissant pour les erreurs complexes. ## 3. Résumé Les boucles sont des outils puissants mais source d'erreurs fréquentes. Les principaux pièges incluent les erreurs de "un de trop / un de moins", les boucles infinies et les conditions incorrectes. Les techniques de débogage comme le tracé manuel et les affichages intermédiaires sont indispensables pour identifier et corriger ces problèmes. La rigueur dans la conception et le test des boucles est fondamentale pour écrire des algorithmes corrects et robustes. ## 🗓️ Historique > **Dernière mise à jour :** `26 octobre 2025` > **Rédigé par :** [[Julien DUQUENNOY]]