Comprendre et utiliser les boucles dans la programmation Delphi

La boucle est un élément commun à tous les langages de programmation. Delphi en a trois Structures de contrôle qui exécutent des blocs de code à plusieurs reprises: pour, répéter... jusqu'à ce que... faire.

Supposons que nous devions répéter une opération un nombre fixe de fois.

// affiche les boîtes de message 1,2,3,4,5
var j: entier;
commencer
pour j: = 1 à 5 faire
commencer
ShowMessage ('Box:' + IntToStr (j));
fin;
fin;

La valeur d'une variable de contrôle (j), qui n'est en fait qu'un compteur, détermine combien de fois une instruction for s'exécute. Le mot clé pour configurer un compteur. Dans l'exemple précédent, la valeur de départ du compteur est définie sur 1. La valeur de fin est définie sur 5.
Lorsque l'instruction for commence à s'exécuter, la variable de compteur prend la valeur de départ. Delphes que vérifie si la valeur du compteur est inférieure à la valeur de fin. Si la valeur est supérieure, rien n'est fait (l'exécution du programme passe à la ligne de code suivant immédiatement le bloc de code de boucle for). Si la valeur de départ est inférieure à la valeur de fin, le corps de la boucle est exécuté (ici: la boîte de message s'affiche). Enfin, Delphi ajoute 1 au compteur et redémarre le processus.

Parfois, il faut compter à rebours. le vers le bas Le mot clé spécifie que la valeur d'un compteur doit être décrémentée de un à chaque exécution de la boucle (il n'est pas possible de spécifier un incrément / décrément autre que un). Un exemple de boucle for qui compte en arrière.

var j: entier;
commencer
pour j: = 5 vers le bas 1 faire
commencer
ShowMessage ('T moins' + IntToStr (j) + 'secondes');
fin;
ShowMessage ('Pour séquence exécutée!');
fin;

Remarque: il est important de ne jamais modifier la valeur de la variable de contrôle au milieu de la boucle. Cela entraînerait des erreurs.

L'écriture d'une boucle for dans une autre boucle for (imbrication de boucles) est très utile lorsque vous souhaitez remplir / afficher des données dans un tableau ou une grille.

var k, j: entier;
commencer
// cette double boucle est exécutée 4x4 = 16 fois
pour k: = 1 à 4 faire
pour j: = 4 vers le bas 1 faire
ShowMessage ('Boîte:' + IntToStr (k) + ',' + IntToStr (j));
fin;

La règle d'imbrication des boucles for-next est simple: la boucle interne (compteur j) doit être terminée avant la prochaine instruction de la boucle externe (compteur k). Nous pouvons avoir des boucles imbriquées triplement ou quadruplement, voire plus.

Remarque: En règle générale, les mots clés de début et de fin ne sont pas strictement requis, comme vous pouvez le voir. Si begin et end ne sont pas utilisés, l'instruction suivant immédiatement l'instruction for est considérée comme le corps de la boucle.

Si vous disposez de Delphi 2005 ou d'une version plus récente, vous pouvez utiliser la "nouvelle" itération de style pour l'élément dans la collection sur les conteneurs. L'exemple suivant montre itération sur les expressions de chaîne: pour chaque caractère dans la chaîne, vérifiez si le caractère est 'a' ou 'e' ou 'i'.

const
s = 'À propos de la programmation Delphi';
var
c: char;
commencer
pour c dans s faire
commencer
si c dans ['a', 'e', ​​'i'] ensuite
commencer
// faire quelque chose
fin;
fin;
fin;

Parfois, nous ne savons pas exactement combien de fois une boucle doit se répéter. Et si nous voulons répéter une opération jusqu'à ce que nous atteignions un objectif spécifique?

La différence la plus importante entre la boucle while-do et la boucle repeat-until est que le code du répéter la déclaration est toujours exécuté au moins une fois.

Le modèle général lorsque nous écrivons un type de boucle de répétition (et while) dans Delphi est le suivant:

répéter
commencer
déclarations;
fin;
jusqu'à condition = true

tandis que condition = true faire
commencer
déclarations;
fin;

Voici le code pour afficher 5 boîtes de message successives en utilisant la répétition jusqu'à:

var
j: entier;
commencer
j: = 0;
répéter
commencer
j: = j + 1;
ShowMessage ('Box:' + IntToStr (j));
fin;
jusqu'à j> 5;
fin;

Comme vous pouvez le voir, l'instruction repeat évalue une condition à la fin de la boucle (donc la boucle de répétition est exécutée à coup sûr au moins une fois).

L'instruction while, en revanche, évalue une condition au début de la boucle. Étant donné que le test est effectué en haut, nous devons généralement nous assurer que la condition est logique avant le traitement de la boucle, si ce n'est pas le cas, compilateur peut décider de supprimer la boucle du code.

var j: entier;
commencer
j: = 0;
tandis que j <5 faire
commencer
j: = j + 1;
ShowMessage ('Box:' + IntToStr (j));
fin;
fin;

Les procédures Break and Continue peuvent être utilisées pour contrôler le flux d'instructions répétitives: The Break provoque le flux de contrôle pour quitter une instruction for, while ou repeat et continuer à la prochaine déclaration suivre la boucle déclaration. Continuer permet au flux de contrôle de passer à la prochaine itération de l'opération répétée.