samedi 29 janvier 2000

Structure de flux


STRUCTURE DE FLUX

Les structures de flux permettent de choisir le déroulement du programme. Nous allons voir deux groupes de structures de flux.
  • instruction alternative
  • instruction répétitive

Instruction alternative

Ces instructions permettent d'exécuter certaines parties de programmes selon certains critères. Nous allons voir le if, if..else et le case.

Insctruction if

La syntaxe n'est pas la même dépendant du nombre d'instruction
Instruction simple Multiple instruction
if <instruction> then
         <opération>
if <instruction> then 
      begin
        <opération>;
        <opération>;
      end;
if NbEnfant > 3 then
        AjouterFrais;
      
if Frais > 1200 then 
      begin
        CalculerTaxe(Frais);
        SommeTotale;
      end;

Insctruction if else

Cette instruction est nécessaire lorsqu'on désire rajouter des opérations à effectuer lorsque la condition n'est pas remplie. On ne doit pas mettre de point virgule lorsqu'il y a seulement une instruction au if, mais on en met un pour le else.

Instruction simple Multiple instruction
if <instruction> then
        <opération> 
      else
        <opération>;
      end;
if <instruction> then begin 
   <opération>;
end else begin
   <opération>;
   <opération>; 
end;
if NbChaine < 20 then
        Commander
      else
        FaireInventaire;
      end;
if NbAuto > 18 then 
      begin
        NbAuto:=NbAuto+3;
      end 
      else begin
        NbAuto:=NbAuto+8;
        Recalculer(NbAuto);
      end;

Insctruction if imbriquée

On peut imbriquer les instructions if si nécessaire, mais si on doit en imbriquer plusieurs, il est préférable d'utiliser le case afin d'améliorer la clarté de notre code.
if x > 10 then 
begin 
  x := x + 5;
  if x > 20 then 
  begin
    x := x + 15;
    if x < 100 then 
    begin
      x := x + 25;
    end;
  end;
end;

Insctruction case

On peut remplacer des if imbriquées par un case. On gagne en compréhension.
case x of
  10..19: x := x + 5;
  20..25: x := x + 15;
else
  x := x + 25;
end;

Instruction répététive

Ces instructions permettent de réexécuter certaines parties de programmes sans qu'il soit nécessaire de les réécrire.

Boucle for

Une valeur initiale et une valeur finale sont nécessaires pour le fonctionnement de cette boucle. On incrémente et décrémente que par pas de 1, ce qui est un peu étrange lorsqu'on a déjà programmé dans d'autres langages. Habituellement, on utilise cette boucle lorsqu'on connaît le nombre de fois qu'on va parcourir la boucle. On est toutefois pas obligé de suivre cette logique, mais pourquoi pas se standardiser?

Le mot to permet d'incrémenter
for <valeur_initiale> to <valeur_final> do begin
  instruction;
end;

for ligne:=0 to maxLigne 
do 
   Calculer(tabNote); 
end;

On doit rajouter begin si le bloc comporte plusieurs instructions

for ligne:=0 to maxLigne do
begin
  Calculer(tabNote);
  Afficher(tabNote);
end;

Le mot downto permet de décrémenter

for ligne:=maxLigne downto do
begin
  Calculer(tabNote);
end;

Décrementer signifie de diminuer à chaque itération de la boucle.

Boucle while

Cette boucle teste à chaque itération si la valeur est vraie (true).
while <expression> do begin
    <instruction>
  end;
  // lire jusqu'à la fin d'un fichier
  while not Eof(InputFile) do begin
    Readln(InputFile, Line);
    Process(Line);
  end;
  while tabNote[Colonne,Min] < tabNote[Colonne,Mid] do begin 
    Inc(Min);
  end;

Boucle repeat

La boucle repeat équivaut à la boucle do while en langage c. Cette boucle ressemble beaucoup à une boucle while, elle évalue l'expression qu'à la fin de la boucle. Les instructions de la boucle seront ainsi exécutées au moins une fois.

repeat
    <instruction>
    until <expression>;
    repeat   
    inc(Min);
  until tabNote[Colonne,Min] < tabNote[Colonne,Mid];