Introduction

La structures de contrôle itératives, aussi nommé boucle, permet de modifier l'ordre d'exécution séquentiel d'un programme afin qu'il modifie l'état de registres ou de variables d'un programme afin qu'il effectue des choix logique et provoque des comportement ne suivant pas nécessaire une séquence. Ainsi, grâce au structures de contrôle itératives, il est possible d'ajuster le comportement d'un programme afin qu'il passe immédiatement à une partie précise de la séquence d'exécution ou de changer l'emplacement d'exécution dans la séquence à cause qu'une valeur a été constaté dans un registre ou dans une variable.

Les types principaux de structures de contrôle itératives :

• Boucle for : La boucle for est utilisée pour itérer un nombre déterminé de fois. Elle est généralement utilisée lorsque vous savez à l'avance combien de fois la boucle doit s'exécuter. Voici l'algorithme d'une boucle FOR :

BOUCLE POUR I ← début JUSQU'A fin     * Code à exécuter pour chaque valeur de I (de début jusqu'à fin) FIN BOUCLE POUR

Exemple en C :

1. for(int i = 0; i < 10; i++) {
2.  /* Code à exécuter pour chaque valeur de i (de 0 à 9) */
3. }

Exemple en Pascal d'une boucle incrémental :

1. Var
2.  i:Integer;
3. Begin
4.  For i := 1 to 10 do Begin
5.   (* Code à exécuter pour chaque valeur de i (de 1 à 10) *)
6.  End;
7. End;

Voici un exemple en Pascal d'une boucle avec décrémentation (utilisation de DOWNTO) :

1. Var
2.  i:Integer;
3. Begin
4.  For i:=10 downto 1 do Begin
5.    (* Code à exécuter pour chaque valeur de i (de 10 à 1) *)
6.  End;
7. End;

Exemple en Python :

1. for i in range(10):
2.      # Code à exécuter pour chaque valeur de i (de 0 à 9)


• Boucle while : La boucle while continue à s'exécuter tant qu'une condition est vraie. Elle est utile lorsque vous ne savez pas combien de fois la boucle doit s'exécuter à l'avance. Voici l'algorithme d'une boucle WHILE :

BOUCLE TANT QUE conditionvrai     * Code à exécuter tant que la condition est vrai FIN BOUCLE TANT QUE

Voici un exemple en Pascal :

1. Var
2.  i:Integer;
3. Begin
4.  i:=1;
5.  While i<=10 do Begin
6.   (* Code à exécuter tant que i est inférieur ou égal à 10 *)
7.   i:=i+1;
8.  End;
9. End;

Exemple en C :

1. int i=0;
2. while(i < 10) {
3.  /* Code à exécuter tant que i est inférieur à 10 */
4.  i++;
5. }

Exemple en Python :

1. i = 0
2. while i < 10:
3.      # Code à exécuter tant que i est inférieur à 10
4.      i += 1


• Boucle do-while (en C) / Boucle repeat-until (en Pascal) : Cette boucle s'exécute au moins une fois, puis continue tant qu'une condition est vraie (ou fausse, selon le langage). La condition est testée après chaque itération. Voici l'algorithme :

BOUCLE REPETER     * Code à exécuter tant que la condition est vrai BOUCLE JUSQU'A conditionvrai

Exemple en C (do-while) :

1. int i = 0;
2. do {
3.  /* Code exécuté au moins une fois */
4.  i++;
5. } while (i < 10);


• Exemple en Pascal (repeat-until) :
  1. i:=0;
  2. Repeat
  3.  (* Code exécuté au moins une fois *)
  4.  i:=i+1;
  5. Until i=10;
• Boucle foreach ou équivalente : Dans de nombreux langages de programmation, une boucle spéciale, souvent appelée foreach, est utilisée pour parcourir directement les éléments d'une collection (liste, tableau,...).

BOUCLE POUR CHAQUE element ← ensemblededonnées     * Code à exécuter pour chaque valeur de element (de début jusqu'à fin) FIN BOUCLE POUR

Voici un exemple en Delphi :

1. Var
2.  fruit:String;
3.  fruits:Array of string;
4. Begin
5.  fruits := ['ananas', 'banane', 'cerise'];
6.  For fruit in fruits do Begin
7.   (* Code exécuté pour chaque élément du tableau fruits *)
8.   WriteLn(fruit);
9.  End;
10. End;

Exemple en Python (for équivalent à foreach) :

1. fruits = ['apple', 'banana', 'cherry']
2. for fruit in fruits:
3.     # Code exécuté pour chaque élément de la liste 'fruits'
4.     print(fruit)

Exemple en C# (foreach) :

1. string[] fruits = { "ananas", "banane", "cerise" };
2. foreach (string fruit in fruits) {
3.  /* Code exécuté pour chaque élément de la collection */
4.  Console.WriteLine(fruit);
5. }

Raison d'utilisation des structures itératives

• Réduction de la redondance : Éviter la répétition manuelle du même code.
• Automatisation : Exécuter des actions multiples de manière automatisée (ex. parcourir un tableau, traiter des fichiers).
• Dynamisme : Permettre l'exécution basée sur des conditions ou des données d'entrée inconnues au moment de l'écriture du code.

Conclusion

Les structures de contrôle itératives permettent de répéter des blocs de code selon des conditions spécifiques, ce qui est essentiel pour l'efficacité et la lisibilité du code dans la plupart des programmes informatiques.