Boucle (instruction)

En programmation informatique , une boucle est une structure de contrôle qui permet d'exécuter du code de manière répétée, généralement avec de légères modifications entre chaque exécution. Les boucles peuvent servir à effectuer une action répétée sur tous les éléments d'une collection ou à implémenter un programme de longue durée.

Les boucles sont une caractéristique des langages de programmation de haut niveau . Dans les langages de programmation de bas niveau, la même fonctionnalité est obtenue par des sauts . Lorsqu'un programme est compilé en code machine , les boucles peuvent être réalisées à l'aide de sauts ; cependant, certaines boucles peuvent être optimisées pour s'exécuter sans saut.

En général, les boucles sont conçues pour s'exécuter un nombre fini de fois. Sans précautions, il est possible de créer accidentellement des boucles infinies. Le problème consistant à déterminer si un programme contient une boucle infinie est appelé problème de l' arrêt .

Une boucle conditionnelle (également appelée boucle indéterminée ) est une boucle qui détermine si elle doit se terminer en fonction d'une condition logique. Ces boucles sont flexibles, mais leur comportement exact peut être difficile à prévoir.

Une boucle conditionnelle est généralement composée de deux parties : une condition et un corps . La condition est une instruction logique dépendant de l’état du programme et le corps est un bloc de code qui s’exécute tant que la condition est vraie.

On croit souvent, à tort, que l'exécution du corps de la fonction s'arrête dès que la condition n'est plus vérifiée ; or, ce n'est généralement pas le cas. Dans la plupart des langages de programmation, la condition est vérifiée une fois par exécution du corps de la fonction . Le moment de cette vérification n'est pas standardisé et certains langages proposent plusieurs structures de boucles conditionnelles avec des règles différentes quant au moment où la condition est évaluée.

Une boucle avec pré-test est une boucle conditionnelle où la condition est vérifiée avant l'exécution du corps du code. Plus précisément, la condition est vérifiée et, si elle est vraie, le corps du code est exécuté. Ensuite, la condition est vérifiée à nouveau et, si elle est vraie, le corps du code est exécuté une nouvelle fois. Ce processus se répète jusqu'à ce que la condition ne soit plus vraie. De nombreux langages de programmation appellent cette boucle une boucle « while » et y font référence avec le mot-clé `while` . Leur format est généralement similaire à celui-ci :

tant que la condition fait que le corps répète

Au lieu des mots clés faire et répéter , d'autres méthodes sont parfois utilisées pour indiquer où le corps commence et se termine, comme les accolades ou les espaces blancs .

Par exemple, le fragment de code suivant vérifie d'abord si x est inférieur à cinq, ce qui est le cas, puis entre dans le corps du programme . La valeur de x y est affichée, puis incrémentée de un. Après l'exécution des instructions du corps du programme , la condition est vérifiée à nouveau et la boucle est réexécutée. Ce processus se répète jusqu'à ce que x atteigne la valeur cinq.

x ← 0 tant que x < 5 faire afficher( x ) x ← x + 1 répéter

Une boucle post-test est une boucle conditionnelle où la condition est vérifiée après l'exécution du corps . Plus précisément, le corps est exécuté, puis la condition est vérifiée. Si elle est vraie, le corps est exécuté à nouveau, puis la condition est vérifiée. Ce processus est répété jusqu'à ce que la condition soit fausse. On parle parfois de boucle « do-while » en raison de la syntaxe utilisée dans divers langages de programmation , bien que cela puisse prêter à confusion, car Fortran et PL/I utilisent la syntaxe « DO WHILE » pour les boucles pré-test . Les boucles post-test sont généralement formatées de manière similaire à…

faire répéter le corps tant que condition

Au lieu des mots clés « do » et « repeat », d’autres méthodes sont parfois utilisées pour indiquer où le corps du texte commence et se termine, comme les accolades.

Certains langages peuvent utiliser une convention de nommage différente pour ce type de boucle. Par exemple, les langages Pascal et Lua possèdent une boucle « repeat until », qui continue de s’exécuter jusqu’à ce que l’expression de contrôle soit vraie, puis se termine.

La boucle `for` en trois parties , popularisée par le langage C, comporte deux parties supplémentaires : l’initialisation ( variante de boucle ) et l’incrémentation , qui sont toutes deux des blocs de code. L’ initialisation sert à préparer la boucle et est exécutée une seule fois au début, tandis que l’incrémentation permet de mettre à jour l’état du programme après chaque itération. Autrement, la boucle `for` en trois parties est une boucle de pré-test. Leur formatage est généralement similaire à celui-ci :

Pour l'initialisation , la condition , l'incrémentation , faire le corps répéter

Cette syntaxe provient du B et a été inventée à l'origine par Stephen C. Johnson . Le code C suivant est un exemple de boucle en trois parties qui imprime les nombres de 0 à 4.

for ( int i = 0 ; i < 5 ; i ++ ) { printf ( "%d " , i ); }

En supposant qu'il existe une fonction ou une méthode correctement déclarée appelée do_work(), les éléments suivants sont équivalents dans les langages de programmation qui prennent en charge les boucles post-test.

faire faire_travailler() répéter tant que la condition

faire_travail() tant que condition faire faire_travailler() répéter

De plus, étant donné qu'aucune continueinstruction n'est utilisée, ce qui précède est techniquement équivalent à ce qui suit, bien que ces exemples ne correspondent pas au style typique ou moderne utilisé dans les ordinateurs courants.

bien que vrai faire_travailler() si la condition n'est pas vraie, alors interrompre la boucle .

ou bien,

DÉBUT DE BOUCLE : faire_travailler() si la condition est remplie , alors aller à LOOPSTART fin si

Une énumération (également appelée boucle déterminée ) est une boucle conçue pour parcourir tous les éléments d'une collection . Moins flexible qu'une boucle conditionnelle, elle est en revanche plus prévisible. Par exemple, il est plus facile de garantir la fin d'une énumération et d'éviter les erreurs de décalage d'un élément . Les énumérations peuvent être implémentées à l'aide d'un itérateur , de manière implicite ou explicite.

Selon le langage de programmation, différents mots clés sont utilisés pour invoquer les énumérations. Par exemple, les descendants d' ALGOL utilisent ` for, , tandis que les descendants de Fortran utilisent do et COBOL utilise PERFORM VARYING`.`

Les énumérations sont parfois appelées « boucles for », par exemple en Zig et Rust . Cela peut prêter à confusion, car de nombreux langages de programmation populaires , tels que C, C++ et Java , utilisent ce terme pour la boucle for en trois parties, qui n'est pas une énumération. D'autres langages de programmation, tels que Perl et C# , évitent cette confusion en utilisant le terme « boucle foreach ».

L’ordre dans lequel les éléments d’une collection sont parcourus dépend du langage de programmation. Fortran 95 possède une boucle, appelée à l’aide du mot-clé `loop` FORALL, qui est indépendante de cet ordre. Elle a pour effet d’exécuter chaque itération de la boucle simultanément. Cette fonctionnalité a été rendue obsolète dans Fortran 2018.

Dans la plupart des langages de programmation fonctionnelle , la récursivité est utilisée à la place des boucles traditionnelles. Ceci est dû au fait que les variables sont immuables , et donc l' incrémentation d'une boucle ne peut avoir lieu.

Pour éviter les erreurs de dépassement de pile pour les boucles longues, les langages de programmation fonctionnelle implémentent l'optimisation des appels terminaux , qui permet d'utiliser le même cadre de pile pour chaque itération de la boucle, compilant ainsi le même code qu'une boucle while ou for .

Certains langages, comme Haskell , possèdent une syntaxe appelée compréhension de liste , similaire à l'énumération, qui consiste à parcourir le contenu d'une liste et à le transformer en une nouvelle liste.

Un compteur de boucle est une variable de contrôle qui détermine le nombre d'itérations d'une boucle. Ce compteur change à chaque itération, lui attribuant une valeur unique. Il sert à déterminer quand la boucle doit se terminer. On l'appelle ainsi car, dans la plupart des cas, cette variable prend des valeurs entières.

Une convention courante pour nommer les identificateurs consiste à utiliser les noms de variables i , j et k (et ainsi de suite si nécessaire) pour le compteur de boucle , où i représente la boucle la plus externe, j la boucle immédiatement interne, etc. Cette convention est généralement attribuée aux débuts de la programmation en Fortran, où ces noms de variables commençant par ces lettres étaient implicitement déclarés comme étant de type entier, et constituaient donc un choix évident pour les compteurs de boucle, dont le rôle n'était que temporaire. Cette pratique remonte plus loin encore, à la notation mathématique où les indices des sommes et des multiplications sont souvent i , j et k .

L’utilisation de noms concis pour les compteurs de boucle, tels que i et j , est déconseillée par certains, car la fonction de ces variables n’est pas aussi claire que si elles portaient un nom plus long et plus descriptif.

Les règles relatives à la valeur du compteur de boucle varient selon les langages, et certains prévoient même qu'il devienne indéfini. Ceci permet au compilateur de générer du code qui laisse n'importe quelle valeur au compteur de boucle, voire la laisse inchangée car sa valeur était stockée dans un registre et jamais en mémoire. Le comportement réel peut même varier selon les paramètres d'optimisation du compilateur.

Modifier le compteur de boucle à l'intérieur du corps de la boucle peut entraîner des conséquences inattendues. Pour éviter de tels problèmes, certains langages rendent le compteur de boucle immuable . Cependant, seules les modifications manifestes sont susceptibles d'être détectées par le compilateur. Lorsque l'adresse du compteur de boucle est passée comme argument à une sous-routine , la vérification est très difficile car le comportement de la routine est généralement inconnu du compilateur, sauf si le langage prend en charge les signatures de procédure et les intentions des arguments.

Certains langages peuvent également fournir des instructions permettant de modifier le déroulement d'une itération de boucle. Parmi celles-ci, on trouve notamment l' instruction `break` , qui interrompt la boucle en cours, et l' instruction `continue` , qui passe à l'itération suivante. Ces instructions peuvent porter d'autres noms ; par exemple, en Fortran 90 , elles sont appelées `exit` et `cycle` .

Une boucle peut également être terminée en quittant la fonction dans laquelle elle est exécutée.

Dans le cas de boucles imbriquées, les instructions ` break` et ` continue` s'appliquent à la boucle la plus interne. Certains langages permettent d'étiqueter les boucles. Ces instructions peuvent alors être appliquées à n'importe quelle boucle imbriquée dans le programme.

boucle_externe : (Il s'agit d'une étiquette pour la boucle la plus externe) pour 1 ≤ i ≤ 2 faire pour 1 ≤ j ≤ 2 faire afficher(i, j) si i = 2 continuer boucle_externe fin si répéter répéter (Cette boucle imbriquée affiche les paires (1, 1), (1, 2) et (2, 1))

Une boucle infinie est une boucle qui ne se termine jamais. Cela peut être intentionnel ou résulter d'une erreur logique .

La détection systématique des boucles infinies est connue sous le nom de problème de l'arrêt .

Les boucles infinies sont utiles dans les applications qui doivent effectuer un calcul répété jusqu'à ce qu'un programme se termine, comme les serveurs Web .