Chapitre 6 - Structures répétitives▲
For … := … to … do …▲
Cette instruction permet d'incrémenter une variable à partir d'une valeur inférieure jusqu'à une valeur supérieure et d'exécuter une ou des instructions entre chaque incrémentation. Les extrema doivent être de type scalaire. La boucle n'exécute les instructions de son bloc interne que si la valeur inférieure est effectivement inférieure ou égale à celle de la borne supérieure.
Le pas de variation est l'unité et ne peut pas être changé.
Syntaxe :
For
variable := borne_inferieure to
borne_superieure do
{instruction}
;
Autre syntaxe :
For
variable := borne_inferieure to
borne_superieure do
begin
...
end
;
Exemple :
Program
Exemple5;
Var
i : Integer
;
Begin
For
i := 10
to
53
do
WriteLn ('Valeur de i : '
, i);
End
.
For … := … downto … do …▲
Cette instruction permet de décrémenter une variable à partir d'une valeur supérieure jusqu'à une valeur inférieure et d'exécuter une ou des instructions entre chaque décrémentation.
S'appliquent ici les mêmes remarques que précédemment.
Syntaxe :
For
variable := borne_superieure downto
borne_inferieur do
{instruction}
;
Autre syntaxe :
For
variable := borne_superieure downto
borne_inferieure do
begin
...
end
;
Exemple :
Program
Exemple6;
Var
i : Integer
;
Begin
For
i := 100
downto
0
do
begin
WriteLn ('Valeur de i : '
, i );
end
;
End
.
Repeat … until …▲
Cette boucle effectue les instructions placées entre deux bornes (repeat et until) et évalue à chaque répétition une condition de type booléenne avant de continuer la boucle pour décider l'arrêt ou la continuité de la répétition.
Il y a donc au moins une fois exécution des instructions.
Syntaxe :
Repeat
...
until
condition_est_vraie;
Exemple :
Program
Exemple7;
Var
i : Integer
;
Begin
Repeat
Inc(i);
Writeln ('Boucle itérée '
, i, ' fois.'
);
until
i > 20
;
End
.
Ce programme Exemple7 permet de répéter l'incrémentation de la variable i jusqu'à ce que i soit supérieur à 20.
Note :
L'instruction Inc permet d'incrémenter une variable d'une certaine valeur. L'instruction Dec permet au contraire de décrémenter une variable d'une certaine valeur. Si la valeur en question est 1, elle peut être omise.
Ces instructions permettent d'éviter la syntaxe : variable := variable + 1 et variable := variable - 1.
Syntaxe :
Inc(variable,nombre);
Dec(variable); (* Décrémentation de 1 *)
While … do …▲
Ce type de boucle, contrairement à la précédente, évalue une condition avant d'exécuter des instructions.
C'est-à -dire qu'on peut ne pas entrer dans la structure de répétition si les conditions ne sont pas favorables.
Syntaxe :
While
condition_est_vraie do
{instruction}
;
Autre syntaxe :
While
condition_est_vraie do
begin
...
end
;
Exemple :
Program
Exemple8;
Var
CodeCorrect : Boolean
;
Essai : String
;
Const
LeVraiCode = 'password'
;
Begin
CodeCorrect := False
;
While
not
CodeCorrect do
begin
Write
('Entrez le code secret : '
);
Readln(Essai);
if
Essai = LeVraiCode then
CodeCorrect := True
;
end
;
End
.
Break▲
Il est possible de terminer une boucle For, While ou Repeat> en cours grâce à la commande Break lorsque celle-ci est placée au sein de la boucle en question.
Exemple :
Program
Arret;
Var
i, x : Integer
;
Begin
x := 0
;
Repeat
Inc(i);
Break;
x := 50
;
until
i > 10
;
WriteLn(i);
WriteLn(x);
End
.
L'exécution des instructions contenues dans la boucle repeat est stoppée à l'instruction Break, et donc x := 50; n'est jamais exécuté. En sortie de boucle, i vaudra donc 1 et x vaudra 0.
Continue▲
Continue interrompt l'exécution du tour de boucle en cours, et renvoie à l'instruction de fin du bloc d'instructions de la boucle, qui passe alors au tour suivant (ou s'arrête, si la condition d'arrêt est vraie).
Par exemple, avec le programme suivant :
Program
test_continue;
Var
i : Integer
Begin
i := 0
;
while
i < 13
do
begin
Inc(i);
if
i < 10
then
Continue;
WriteLn('i = '
,i);
end
;
End
.
on obtient comme résultat :
i = 10
i = 11
i = 12
i = 13
car la ligne
if
i < 10
then
Continue;
renvoie à la fin de la boucle si i est inférieur à 10, et renvoie donc au end; ,ce qui fait sauter le Writeln('i = ',i); et la boucle reprend au début tant que la condition de sortie reste fausse.
Le principe est le même pour les autres types de boucles.