Section courante

A propos

Section administrative du site

Contrôle du déroulement du programme

Comme d'autres langages de programmation de haut niveau, le Pascal offre une grande variété de façons de contrôler le flux d'exécution d'un programme. Cette page traite des instructions en boucle, effectuant des actions répétitives, et des instructions de prise de décision, transférant le contrôle sur la base de tests logiques. Avant d'examiner ces instructions en détail, cette page résume brièvement les opérateurs utilisés dans les tests logiques.

Opérateurs relationnels et booléens

Toutes les instructions de bouclage et de branchement en Pascal dépendent du résultat d'un test booléen (vrai ou faux). De tels tests utilisent des opérateurs relationnels et booléens, semblant familiers à quiconque connaît BASIC ou C.

Même si vous n'avez jamais vu une ligne de code Pascal, vous pouvez deviner que l'instruction :

  1. If my_val = 20 Then Writeln('my_val égale 20');

affiche le message :

my_val égale 20

si la valeur de la variable my_val est égale à 20. (L'instruction IF de Pascal, comme vous le lirez plus loin dans cette page, fonctionne très bien comme IF en BASIC et C.)

L'exemple utilise l'opérateur d'égalité (=) pour comparer la variable my_val à la constante 20. Il produit un résultat True lorsque my_val est égal à 20 et un résultat False dans tous les autres cas.

Les constantes True et False sont des valeurs symboliques en Pascal. Bien qu'ils soient représentés par des chiffres réels en interne, vous n'avez pas à vous soucier de ces chiffres.

Les opérateurs relationnels, y compris l'opérateur d'égalité, comparent deux valeurs et produisent un résultat True ou False. Le tableau suivant liste tous les opérateurs relationnels Pascal :

Opérateur Description
= Équal
<> Pas d'égalité
< Inférieur à
> Supérieur à
<= Inférieur ou égale
>= Supérieur ou égale

Un deuxième groupe d'opérateurs permet d'effectuer des opérations logiques booléennes. Ils sont répertoriés dans le tableau suivant :

Opérateur Description
NOT Négation
AND ET logique
OR OU logique
XOR OU exclusif

Les opérateurs booléens (sauf NOT) peuvent agir sur une ou deux valeurs, permettant des tests logiques plus complexes. Par exemple, l'énoncé :

  1. If((my_val > 3)and(my_val < 20))Then WriteLn('Waouh !');

teste deux conditions au lieu d'une. Il affiche le message :

Waouh !

si la valeur de my_val est supérieure à 3 et inférieure à 20. Le Pascal fournit beaucoup plus d'opérateurs, mais ce sont ceux étant importants pour contrôler le déroulement du programme. Le QP Advisor contient des informations sur tous les opérateurs QuickPascal.

Instructions en boucle

Une boucle effectue l'une des opérations informatiques les plus élémentaires : répéter une action. Cette section traite des instructions de bouclage Pascal : WHILE, REPEAT et FOR.

Boucles WHILE

Une boucle WHILE est le type de boucle le plus simple. Il se répète 0 fois ou plus, tant qu'une condition donnée reste vraie. Le programme QWHILE.PAS contient une simple boucle WHILE :

  1. Program qwhile;
  2.  { QWHILE.PAS: Démonstration de boucle WHILE. }
  3. Var
  4.  count:Integer;
  5.  
  6. BEGIN
  7.  count := 0;
  8.  While count<10 do begin
  9.   Writeln('compteur = ',count);
  10.   count:=count+2;
  11.  End;
  12. END.

Voici la sortie de QWHILE.PAS :

compteur = 0
compteur = 2
compteur = 4
compteur = 6
compteur = 8

Une boucle WHILE commence par le mot clef WHILE suivi d'une condition. La boucle se répète tant que la condition reste vraie. Dans QWHILE.PAS, la condition est :

  1. count < 10

la boucle continue donc tant que la valeur de la variable count est inférieure à 10. Après la condition se trouve le mot clef DO suivi d'un «corps de boucle», pouvant être une instruction unique ou un bloc d'instructions. Dans QWHILE.PAS, le corps de la boucle est un bloc d'instruction :

  1. Begin
  2.  Writeln('compteur = ',count);
  3.  count:=count+2;
  4. End;

Vous devez entourer le corps d'une boucle WHILE avec BEGIN et END, même si la boucle n'est qu'une seule instruction. Cette convention évite toute confusion quant à l'endroit où se termine le corps de la boucle.

Il est important de savoir qu'une boucle WHILE teste sa condition avant d'exécuter le corps de la boucle. Contrairement à d'autres types de boucles, il est possible qu'une boucle WHILE saute tout dans son corps de boucle. Si la condition de test est fausse au début d'une boucle WHILE, le corps de la boucle ne s'exécute pas du tout. Par exemple, si count a la valeur 10 lorsque la boucle ci-dessus commence, QWHILE.PAS n'affiche rien.

Boucle REPEAT

Une boucle REPEAT est une boucle WHILE inversée. Il teste la condition après avoir exécuté le corps de la boucle, et la boucle se répète jusqu'à ce que la condition de test devienne vraie.

Le programme QREPEAT.PAS effectue la même tâche que QWHILE.PAS, mais il utilise une boucle REPEAT au lieu d'une boucle WHILE.

  1. Program qrepeat;
  2.  { QREPEAT.PAS: Démonstration de boucle REPEAT }
  3. Var
  4.  count:Integer;
  5.  
  6. BEGIN
  7.  count:=0;
  8.  REPEAT
  9.   Writeln('compteur = ',count);
  10.   count:=count+2;
  11.  UNTIL (count > 8);
  12. END.

La sortie de QREPEAT.PAS et QWHILE.PAS est identique :

compteur = 0
compteur = 2
compteur = 4
compteur = 6
compteur = 8

La boucle REPEAT dans QREPEAT.PAS contient le même corps de boucle que la boucle WHILE dans QWHILE.PAS :

  1. Repeat
  2.  Writeln('compteur = ',count);
  3.  count:=count + 2;
  4. Until (count > 8);

Vous n'avez pas besoin d'entourer le corps de la boucle d'une boucle REPEAT avec les mots-clefs BEGIN et END (bien que les ajouter ne fasse aucun mal). Étant donné que le corps de la boucle est déjà inclus entre deux mots-clefs (REPEAT et UNTIL), il ne peut y avoir de confusion quant au début et à la fin du bloc.

N'oubliez pas qu'une boucle REPEAT exécute toujours le corps de la boucle au moins une fois. Si count a la valeur 10 au début de la boucle, QREPEAT.PAS affiche :

compteur = 10

même si 10 est nettement supérieur à 8, la valeur de seuil dans la condition de test. La valeur de count n'est testée qu'après l'exécution du corps de la boucle.

Notez que les boucles WHILE et REPEAT utilisent des tests logiques opposés. Une boucle WHILE continue tant que la condition de test est vraie, mais une boucle REPEAT continue jusqu'à ce que la condition de test devienne vraie (ou, pour le dire différemment, tant que la condition de test est fausse). Pour illustrer, la boucle WHILE dans QWHILE.PAS continue tant que count est inférieur à 10 :

  1. count < 10

Cependant, la boucle REPEAT dans QREPEAT.PAS continue jusqu'à ce que count soit supérieur à 8 :

  1. count > 8

Boucles FOR

Les boucles WHILE et REPEAT sont idéales dans les cas où vous ne pouvez pas prévoir le nombre de répétitions nécessaires. Un programme obtenant une entrée au clavier, par exemple, peut utiliser REPEAT pour répéter une action jusqu'à ce que vous appuyiez sur une certaine touche. Parfois, cependant, vous savez à l'avance exactement combien de répétitions sont nécessaires.

La boucle FOR répète une instruction, ou un bloc d'instructions, un nombre défini de fois. Le programme QFOR.PAS contient une simple boucle FOR :

  1. Program qfor;
  2.  { QFOR.PAS: Démonstration de boucle FOR }
  3. Var
  4.  count:Integer;
  5.  
  6. BEGIN
  7.  For count:=0 to 10 do Writeln('compteur = ', count);
  8. END.

QFOR.PAS produit cette sortie :

compteur = 0
compteur = 1
compteur = 2
compteur = 3
compteur = 4
compteur = 5
compteur = 6
compteur = 7
compteur = 8
compteur = 9
compteur = 10

La boucle FOR dans QFOR.PAS compte de 0 à 10 par incrémentation de 1 :

  1. For count:=0 to 10 do Writeln('compteur = ',count);

Dans cet exemple, la variable de contrôle count est d'abord définie sur 0. Chaque répétition exécute le corps de la boucle une fois et ajoute 1 à count jusqu'à ce que count atteigne 10, la valeur de fin.

Les boucles FOR peuvent décompter aussi bien que monter. Le mot clef TO fait que la boucle compte par incrémentation de 1, et DOWNTO a l'effet inverse. Si vous remplacez cette boucle dans QFOR.PAS, la boucle compte à rebours de 10 à 0 par incrémentation de 1 :

  1. For count:=10 downto 0 do WriteLn('compteur = ',count);

Le corps de la boucle dans QFOR.PAS se trouve être une seule instruction. Si le corps de la boucle est un bloc d'instructions, vous devez entourer le bloc d'instructions BEGIN et END :

  1. For count:=0 to 10 do Begin
  2.  WriteLn('compteur = ',count);
  3.  WriteLn('Une autre instruction');
  4. End;

Instructions de prise de décision

Les instructions de prise de décision permettent à votre programme d'effectuer différentes actions en fonction du résultat d'un test logique. Cette section examine les déclarations de prise de décision Pascal : IF et CASE.

Instructions IF

Une instruction IF se compose du mot clef IF suivi d'une expression de test et du mot clef THEN. Après THEN est une instruction ou un bloc d'instructions. L'instruction est exécutée si l'expression de test est vraie, ou ignorée si elle est fausse.

Le programme QIF.PAS contient une simple instruction IF :

  1. Program qif;
  2.  { QIF.PAS: Démonstration d'instruction IF. }
  3. Var
  4.  my_val:Integer;
  5.  
  6. BEGIN
  7.  my_val:=3;
  8.  If(my_val = 3)Then Writeln('my_val égale 3');
  9. END.

Voici l'instruction IF de QIF.PAS :

  1. If(my_val = 3)Then Writeln('my_val égale 3');

Dans cet instruction, la condition de test :

  1. (my_val = 3)

compare la variable my_val à la constante 3. Puisque la comparaison est vraie (my_val vaut 3), QIF.PAS affiche :

my_val égale 3

L'instruction suivant THEN peut être une instruction unique ou un bloc d'instructions. Un bloc doit être entouré d'instructions BEGIN et END :

  1. If(my_val = 3)Then Begin
  2.  Writeln('my_val égale 3');
  3.  Writeln('Autre instruction');
  4. End;

Clauses ELSE

Le mot clef ELSE permet à une instruction IF d'effectuer des branchements plus complexes. Le programme QELSE.PAS ajoute une clause ELSE à QIF.PAS :

  1. Program qelse;
  2.  { QELSE.PAS: Démonstration d'une clause ELSE. }
  3. Var
  4.  my_val:Integer;
  5. BEGIN
  6.  my_val:=555;
  7.  If(my_val = 3)Then WriteLn('my_val égale 3')
  8.                Else WriteLn('my_val n''est pas égale à 3')
  9. END.

Le programme QELSE.PAS contient l'instruction IF...ELSE suivante :

  1. If(my_val = 3)Then WriteLn('my_val égale 3')
  2.               Else WriteLn('my_val n''est pas égale à 3');

La clause ELSE permet à l'instruction IF d'effectuer deux actions alternatives. L'instruction IF affiche :

my_val égale 3

si my_val est égal à 3, et il affiche :

my_val n'est pas égale à 3

dans tous les autres cas. Notez qu'un point-virgule ne précède pas ELSE, car ELSE est considéré comme faisant partie de l'instruction IF.

Vous pouvez imbriquer et combiner des instructions IF et des clauses ELSE selon vos besoins. Chaque ELSE est associé au IF précédent le plus proche n'ayant pas encore de ELSE. Considérez cet exemple :

  1. If(my_val > 9)Then
  2.  IF(my_val = 10)Then WriteLn('Dix')
  3.                 Else WriteLn('Plus de neuf, mais pas dix')
  4. Else
  5.  Writeln('Moins de dix');

L'exemple peut prendre trois actions différentes. Si my_val est supérieur à 9 et égal à 10, il affiche Dix. Si my_val est supérieur à 9 mais pas égal à 10, il affiche «Plus de neuf, mais pas dix». Si my_val est inférieur ou égal à 9, il affiche «Moins de dix».

Utilisez un bloc BEGIN...END pour inclure l'instruction IF imbriquée lorsque le ELSE s'applique au IF environnant, comme indiqué ci-dessous :

  1. If(my_val > 9)Then Begin
  2.  If(my_val = 10)Then Writeln( 'Dix' );
  3. End
  4.  Else
  5. WriteLn('Moins de dix');

Cet exemple affiche Dix si my_val est égal à 10, et «Moins de dix» sinon. Sans le bloc BEGIN...END, la clause ELSE s'appliquerait à la condition IF (my_val = 10) et non à IF (my_val > 9).

Instruction CASE

Comme le montre l'exemple précédent, les instructions complexes IF...ELSE peuvent être difficiles à lire. Si toutes les branches testent la même valeur (comme dans l'exemple précédent), l'instruction CASE fournit une solution plus propre.

L'instruction CASE de Pascal est similaire à SELECT CASE en QuickBASIC ou à l'instruction switch en C. Elle peut passer à plusieurs alternatives différentes en fonction de la valeur d'un seul test d'expression ordinale. Le programme QCASE.PAS contient une instruction CASE simple :

  1. Program qcase;
  2.  { QCASE.PAS: Démonstration d'instruction CASE. }
  3.  
  4. Var
  5.  my_val:Integer;
  6. BEGIN
  7.  my_val:=33;
  8.  Case my_val of
  9.   10: Writeln('Dix');
  10.   20: Writeln('Vingt')
  11.   Else Writeln('Pas dix ou vingt');
  12.  End;
  13. END.

Une instruction CASE commence par le mot clef CASE, suivi d'une expression ordinale et du mot clef OF. L'instruction CASE dans QCASE.PAS teste la valeur de my_val :

  1. CASE my_val OF

Vient ensuite une liste d'alternatives, chacune étiquetée avec une constante suivie de deux-points (une "constante de casse") :

  1. 10: Writeln('Dix');
  2. 20: Writeln('Vingt');

Les alternatives à exécuter peuvent être des instructions simples ou des blocs d'instructions. Chaque constante de cas dans la liste agit comme une cible. Lorsque my_val est égal à 10, QCASE.PAS exécute l'instruction après la constante de casse :

  1. 10:

Lorsque my_val est égal à 20, le contrôle est transféré à la constante de cas :

  1. 20:

Lorsque my_val ne correspond à aucune constante de casse, QCASE.PAS exécute l'instruction ELSE suivante :

  1. Else Writeln('Pas dix ou vingt');

La clause ELSE est facultative. Si vous l'omettez et que la valeur de l'expression ne correspond à aucune des constantes CASE, aucune des alternatives n'est exécutée. Au lieu de cela, l'exécution se poursuit avec la première instruction suivant les instructions CASE.

L'instruction CASE peut utiliser autant de constantes de casse que nécessaire. La constante de cas peut être une seule constante (comme indiqué ci-dessus), un groupe ou un intervalle de constantes :

  1. Case my_val of
  2.  1600,2000 : Writeln('Siècle bissextile');
  3.  1601..1999: Writeln('Siècle non bissextile');
  4. End;

La première constante de cas comprend deux valeurs : 1600 et 2000. La seconde comprend une intervalle de 399 valeurs : 1601 à 1999.



Dernière mise à jour : Dimanche, le 28 août 2022