Delphi/Structures conditionnelles et répétitives
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.
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.
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.
