Delphi/Structures conditionnelles et répétitives

Début de la boite de navigation du chapitre

fin de la boite de navigation du chapitre

Introduction

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

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

Exemple

var
  x, y: integer;

begin
  x := 5;  //x = 5
  y := 3;  //y = 3
  if (x = y) then
    begin
    //bloc
    //d'instruction
    end;
end.

Pour alléger la syntaxe il est permis de ne pas utiliser les begin et end s'il n'y a qu'une instruction dans le bloc.

var
  x, y: integer;

begin
  x := 5;  //x = 5
  y := 3;  //y = 3
  if (x = y) then
    //une seule instruction
end.

Le else s'utilise comme ceci

var
  x, y: integer;

begin
  x := 5;  //x = 5
  y := 3;  //y = 3
  if (x = y) then
    begin
    //bloc
    //d'instruction
    end
  else
    begin
    //bloc
    //d'instruction
    end;
end.

Attention le end qui précède le else ne doit jamais être suivit par un ";" Mais ne vous inquiétez pas. Si jamais vous vous trompez, le compilateur vous rappellera gentiment à l'ordre.

Fin de l'exemple

Case

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

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

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

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.