Developpez.com - Pascal
X

Choisissez d'abord la catégorieensuite la rubrique :

 

CHAPITRE VI : Structures répétitives

Par Hugo ETIEVANT

  1. For ... : = ... To ... Do ...
  2. For ... : = ... DownTo ... Do ...
  3. Repeat ... Until ...
  4. While ... Do ...
  5. Arrêts de boucle.
 

1. For ... : = ... To ... Do ...

Cette instruction permet d'incrémenter une variable à partir d'une valeur inférieur jusqu'à une valeur supérieur et d'exécuter une ou des instructions entre chaque incrémentation. Les valeurs extrémum doivent être des entiers (integer) ou des caractères de la table ASCII (char). De manière plus générale, les bornes doivent être de type intervalle (voir chap Type) c'est-à-dire qu'ils doivent êtres de type entier ou compatibles avec un type entier. La boucle n'exécute les instructions de son bloc interne que si la valeur inférieur est effectivement inférieur ou égale à celle de la borne supérieur. Le pas de variation est l'unité et ne peut pas être changé.
Syntaxe :

    For variable := borne inférieur To borne supérieur Do instruction ;

Autre Syntaxe :

    For variable := borne inférieur To borne supérieur Do

      Begin
      ...
      commandes
      ...
      End ;

    Program exemple5 ;
    Var i : integer ;
    BEGIN

      For i := 10 To 53 Do writeln ('Valeur de i : ', i ) ;
    END.

 

2. For ... : = ... DownTo ... Do ...

Cette instruction permet de décrémenter une variable à partir d'une valeur supérieur jusqu'à une valeur inférieur et d'exécuter une ou des instructions entre chaque décrémentation. S'appliquent ici les mêmes remarques que précédement.
Syntaxe :

    For variable := borne supérieur DownTo borne inférieur Do instruction ;

Autre Syntaxe :

    For variable := borne supérieur DownTo borne inférieur Do

      Begin
      ...
      commandes
      ...
      End ;

    Program exemple6 ;
    Var i : integer ;
    BEGIN
      For i := 100 DownTo 0 Do
        Begin
        WriteLn ('
        Valeur de i : ', i ) ;
        End ;
    END.


 

3. 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 boulé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. Il est nécessaire qu'au moins une variable intervenant lors de l'évaluation de fin de boucle soit sujette à modification à l'intérieur de la structure exécutive interne à la boucle.
Syntaxe :

    Repeat
    ...
    commandes
    ...
    Until variable condition valeur ;

    Program
    exemple7 ;
    Uses crt ;
    Var i : integer ;
    BEGIN
      Repeat
        Inc ( i , 1 ) ;
        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'à que i soit supérieure à 20.
Note : la commande Inc permet d'incrémenter une variable d'une certaine valeur. La commande Dec permet au contraire de décrémenter une variable d'une certaine valeur. Ces commandes permettent d'éviter la syntaxe : variable := variable + 1 et variable := variable - 1.
Syntaxe :

    Inc ( variable , nombre ) ;
    Dec (
    variable , nombre ) ;

 

4. While ... Do ...

Ce type de boucle, contrairement à la précédente, évalue une condition avant d'exécuter des instructions (et nom pas l'inverse), c'est-à-dire qu'on peut ne pas entrer dans la structure de répétition si les conditions ne sont pas favorables. De plus, au moins une variable de l'expression d'évaluation doit être sujette à modification au sein de la structure de répétition pour qu'on puisse en sortir.
Syntaxe :

    While variable condition valeur Do instruction ;
Autre Syntaxe :
    While variable condition valeur Do
      Begin
      ...
      commandes
      ...
      End ;
    Program exemple8 ;
    Var
    code : boolean ;
    essai : string ;
    Const
    levraicode = 'password' ;
    BEGIN

      code:=false ; { facultatif, la valeur false est donnée par défault }
      While code = false Do
        Begin
          Write ('Entrez le code secret : ') ;
          Readln (
          essai) ;
          If
          essai = levraicode then code:=true ;
        End ;
    END.


 

5. Arrêts de boucle.

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.

Pour reprendre une boucle stoppée par Break, il faut utiliser la commande Continue.

    Program arrets1 ;
    Var i, x : Integer ;
    BEGIN

      x := 0 ;
        Repeat
          Inc(i) ;
          Break ;
          x := 50 ;
          Continue ;
        Until i>10 ;
      WriteLn(x) ;
    END.

Ce programme arrets1 stoppe systématiquement une boucle Repeat avant que la variable x puisse être incrémenté de 50 et la reprend après la ligne d'incrémentation. Ce qui a pour résultats que la variable x soit nulle à la fin du programme.

    Program arrets2 ;
    Var i, x : Integer ;
    BEGIN

      x := 0 ;
      For i := 1 to 10 Do
        Begin
          Break ;
          x := 50 ;
          Continue ;
        End ;
      WriteLn(x) ;
    END.

Ce programme arrets2 fait la même chose que le programme précédent mais dans une boucle For.

    Program arrets3 ;
    Var i, x : Integer ;
    BEGIN

      x := 0 ;
      While i<10 Do
        Begin
          Break ;
          x := 50 ;
          Continue ;
        End ;
      WriteLn(x) ;
    END.

Ce programme arrets3 fait la même chose que les programmes précédents mais dans une boucle While.

Et pour quitter un bloc sous-programme (structure Begin ... End ;) ou même le programme principal (structure Begin ... End.) , utilisez la commande Exit.

    Program arrets4 ;
    Var i : Integer ;
    BEGIN

      While i <> 13 Do
        Begin
          Write ('Entrez un nombre : ') ;
          Readln (i) ;
          Writeln (i) ;
          If i = 0 Then Exit ;
        End ;
      Writeln ('Boucle terminée.') ;
    END.
Responsables bénévoles de la rubrique Pascal : Gilles Vasseur - Alcatîz -