Comprendre et utiliser les boucles dans la programmation Delphi

Comprendre et utiliser les boucles dans la programmation Delphi

La boucle est un élément commun à tous les langages de programmation. Delphi possède trois structures de contrôle qui exécutent des blocs de code à plusieurs reprises: pour, répéter… jusqu'à et tant que… faire.

La boucle FOR

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

// 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 réalité qu'un compteur, détermine le nombre de fois qu'une instruction for s'exécute. Le mot clé pour met en place un compteur. Dans l'exemple précédent, la valeur initiale du compteur est définie sur 1. La valeur finale est définie sur 5.
Lorsque l'instruction for commence à s'exécuter, la variable counter est définie sur la valeur de départ. Delphi than vérifie si la valeur du compteur est inférieure à la valeur finale. Si la valeur est supérieure, rien n'est fait (l'exécution du programme saute à la ligne de code qui suit 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 est affichée). Enfin, Delphi ajoute 1 au compteur et relance le processus.

Parfois, il est nécessaire de compter en arrière. le vers le bas 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 différent d'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 la 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 provoquerait des erreurs.

Boucles FOR imbriquées

L'écriture d'une boucle for dans une autre boucle for (boucles imbriquées) 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 ('Box:' + IntToStr (k) + ',' + IntToStr (j));
fin;

La règle d'imbrication pour les boucles suivantes 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 trois ou quatre fois, voire plus.

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

La boucle FOR-IN

Si vous avez Delphi 2005 ou une version plus récente, vous pouvez utiliser la "nouvelle" itération de style for-element-in-collection sur les conteneurs. L'exemple suivant illustre une itération sur des expressions de chaîne: pour chaque caractère de 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' puis
commencer
// faire quelque chose
fin;
fin;
fin;

Les boucles WHILE et REPEAT

Parfois, nous ne saurons pas exactement combien de fois une boucle devrait se répéter. Et si nous voulons répéter une opération jusqu'à atteindre un objectif spécifique?

La différence la plus importante entre la boucle While-do et la boucle Repeat-Until réside dans le fait que le code de l'instruction repeat est toujours exécuté au moins une fois.

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

répéter
commencer
les déclarations;
fin;
jusqu'à ce que condition = true
tandis que condition = true faire
commencer
les déclarations;
fin;

Voici le code pour afficher 5 boîtes de message successives à l'aide de repeat-jusqu'à:

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

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

Par contre, l'instruction while évalue une condition au début de la boucle. Comme le test est effectué en haut, nous devrons généralement nous assurer que la condition a du sens avant le traitement de la boucle. Si ce n'est pas le cas, le 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;

Pause et continue

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


Voir la vidéo: Formateur en Programmation - Cours de codage - Delphi Starter - Les boucles