Leçons de niveau 14

Delphi/Structures conditionnelles et répétitives

Une page de Wikiversité.
Sauter à la navigation Sauter à la recherche
Début de la boite de navigation du chapitre
Structures conditionnelles et répétitives
Icône de la faculté
Chapitre no 8
Leçon : Delphi
Chap. préc. :Tableau
Chap. suiv. :Pointeur
fin de la boite de navigation du chapitre
Icon falscher Titel.svg
En raison de limitations techniques, la typographie souhaitable du titre, « Delphi : Structures conditionnelles et répétitives
Delphi/Structures conditionnelles et répétitives
 », n'a pu être restituée correctement ci-dessus.

Introduction[modifier | modifier le wikicode]

Les structures répétitives, ou les boucles, servent comme le nom l'indique à répéter un certain nombre de fois une instruction ou un bloc d'instructions. Un bloc d'instructions est une série d'instructions qui se suivent et qui commence par begin et finisse par end.

If[modifier | modifier le wikicode]

Le if qui se traduit en français par si exprime la condition. On l'associe à then (alors) et accessoirement à else (sinon). Concrètement si l’expression située à côté du if renvoie la valeur booléenne true (vrai) le bloc d'instruction situé après then est exécuté sinon c’est celui situé après else qui l'est. La clause else est facultative, c'est-à-dire que si vous n'avez pas d'instruction à y associer vous n'êtes pas obligés de l'écrire.

Début de l'exemple
Fin de l'exemple


Case[modifier | modifier le wikicode]

Quand on ne peut répondre que par oui ou par non à une question, le if convient très bien (if FaitBeau then sortir le parasol else le ranger). Mais si par exemple on veut traiter de l'âge de quelqu’un se limiter à jeune/vieux est peut être un peu sectaire.

Il arrivait donc souvent de se retrouver avec ça :

if Age in [1..5] then
  Caption := 'Marmot'
  else if Age in [6..10] then
    Caption := 'Gamin'
    else if (Age = 0) or (Age in [10..99]) then
      Caption := 'J''en ai marre je vais pas tous les faire'
      else
        Caption := 'Gné?!';

Comme c’est illisible et fastidieux, on a créé le case (switch en C). La syntaxe du case est la suivante :

case expressionSelection of
  listeCas1: instruction1;
    ...
  listeCasn: instructionn;
  else
  instructions;
  end

où instructions est un suite d'instructions séparées par des points virgules. Quand une instruction case est exécutée, au moins l'une des instruction1 ... instructionn est exécutée. Le listeCas dont la valeur est égale à celle de expressionSelection détermine l'instruction à utiliser. Si aucun des listeCas n'a la même valeur qu'expressionSelection, alors ce sont les instructions de la clause else (s'il y en a) qui sont exécutées.

Donc si on reprend le premier exemple avec un case ça donne :

case Age of
  1..5: Caption := 'Marmot';
  6..9: Caption := 'Gamin';
  0, 10..99: Caption := 'Bon j''en ai pas plus envie mais c''est quand même plus court';
else
  Caption := '';
end;

C'est tout de même plus clair et concis. Par contre, on ne peut utiliser que des valeurs ordonnées, c'est-à-dire que seules les variables d'entiers ou les énumérations peuvent être testés dans un Case.

Repeat[modifier | modifier le wikicode]

L'instruction repeat qui se traduit par "répéter tant que la condition renvoie faux" a la syntaxe suivante :

repeat instruction1; ...; instructionn; until expression

où expression renvoie une valeur booléenne. Le dernier point-virgule avant until est facultatif. L'instruction repeat exécute répétitivement la séquence d'instructions qu'elle contient en testant expression à chaque itération. Quand expression renvoie True, l'instruction repeat s'arrête. La séquence est toujours exécutée au moins une fois car expression n'est évaluée qu'après la première itération.

Voici des exemples d'instructions repeat :

repeat
  K := I mod J;
  I := J;
  J := K;
until J = 0;
repeat
  Write('Entrez une valeur (0..9): ');
  Readln(I);
until (I >= 0) and (I <= 9);

While[modifier | modifier le wikicode]

L'instruction While se traduit par "tant que". Concrètement le bloc d'instruction associé à while se répétera indéfiniment tant que la condition associée renverra la valeur booléenne True(vrai). While est donc similaire à repeat à la différence près que la condition est évalué avant l'exécution. Par conséquent il se peut qu'une boucle while ne soit jamais exécutée alors qu'une repeat garanti au moins une itération.

while (Tableau[Index] <> X) do //Tant que la valeur contenue dans cette "case" du tableau n’est pas celle qu'on attend
  Inc(Index);                 //On se déplace à la case suivante // Inc() signifie Incrémenter, Ajouter 1

Attention : Si jamais la condition ne peut jamais être fausse, vous créez ce qu'on appelle une boucle infinie, votre programme ne se termine jamais. Ce n'est à utiliser que dans des cas très spécifiques. Exemple :

Index := 1;
while True do // 
  //instructions;

Il parait évident que cette boucle ne peut pas se finir.

For[modifier | modifier le wikicode]

La boucle for est une boucle dont le nombre d'exécution est défini, il ne dépend pas d'une condition.

Sa syntaxe est la suivante : for compteur := valeurInitiale to valeurFinale do instruction ou for compteur := valeurInitiale downto valeurFinale do instruction

Avec un exemple ce sera plus clair. Essayez de le comprendre sans commentaire, l'explication est plus bas mais à ce stade vous devriez pouvoir comprendre sans aide. Sinon relisez les cours.

Var
  Index, Moyenne: integer;
  Temperatures: array[1..10] of integer;

begin
  for Index:= 1 to 10 do
    begin
    Write('Entrez la température du jour n°', Index, ': ');
    ReadLn(Temperatures[Index]);
    end;
  for Index:= 10 downto 1 do
    Moyenne := Temperatures[Index] + Moyenne;
  Moyenne = Moyenne div 10;
end.

Explication : Dans la première boucle for on demande à l'utilisateur de saisir des températures relevées sur 10 jours. Dans la seconde on additionne tous les nombres entrés dans la même variable puis on la divise par deux pour en obtenir la moyenne. Vous aurez probablement remarqué que les boucles se prêtent particulièrement aux tableaux.