Table des matières indexe chapitre suivant

Chapitre 8 : Instructions

Tables des matières


0. Introduction

La première partie explique que les déclarations ont pour but de définir des objets manipulés par le programme et d'allouer des cases­mémoire (ou réceptacles) pour leur valeur.

Le chapitre précédent montre que les expressions ont pour but de produire une valeur á partir des valeurs courantes d'objets sans modifier ces dernières non compte tenu des effets de bord des fonctions (cfr Ch 12).

Une instruction peut modifier la valeur d'objets.

Les instructions apparaissent dans la partie instruction d'un programme ou dans la partie instruction d'un sous­programme.


1. Diagrammes syntaxiques

Toute instruction peut être précédée d'au plus une étiquette préalablement déclarée (cfr Ch 1). L'instruction vide est sans effet sur le programme. Elle peut servir dans une phase de mise au point du programme.

Une instruction composée est une séquence d'instructions exécutées dans l'ordre où elles sont écrites.

   begin
        t:=x;
        x:=y;
        y:=t
    end
La dernière instruction d'une instruction composée ne doit pas être suivie d'un point­virgule conformément au diagramme syntaxique. Si on écrit :
    begin
        t:=x;
        x:=y;
        y:=t;
    end
La dernière instruction de l'instruction composée est alors l'instruction vide.

On voit donc que le point­virgule (;) sert á séparer les instructions dans une suite d'instruction formant une instruction composée : il ne fait pas partie des instructions elle­mêmes.

L'instruction appel de procédure est décrite dans le chapitre 11 Les autres instructions sont décrites ci­dessous.


2. Instruction d'affectation

2.1. Diagramme syntaxique

L'instruction d'affectation est une façon de donner une valeur á une variable.

accès á variable structurée est défini en Ch 7.2 et où identificateur de fonction est utilisé dans la partie instruction de la fonction au sens décrit en Ch 12

2.2. Règles relatives á l'affectabilité de valeurs aux variables

Soit Tv le type de la variable.
Soit Te le type de l'expression.
Pour que l'instruction d'affectation soit syntaxiquement correcte, il faut que le type Te soit affectable au type Tv. Pour cela, il faut qu'une des conditions suivantes soit remplie:

Pour que l'instruction d'affectation soit exécutable, il faut qu'elle soit syntaxiquement correcte et que la valeur de l'expression puisse être affectée á la variable en respectant les contraintes exprimées par les types (par exemple : limites exprimées par les bornes d'un intervalle).

    const PI = 3.141592 ;
    type  entier = integer ;
          couleur = (bleu,blanc,rouge,jaune) ;
          tab = array[18..24] of couleur ;
    var   x,y : entier ;
          a,b : real ;
          fanion : couleur ;
          dessin, arcenciel : tab ;
    begin
        x := 3 * 4 + 2 ;
        y := x div 5 ;
        a := PI / 4 ;
        b := - a ;
        fanion := rouge ;
        arc-en-ciel := dessin ;  { si la variable dessin possede une valeur }
        ...
    end.

2.3. Initialisation des variables

Lors d'une déclaratione de variable (cfr Ch 5) , aucune valeur n'est attribuée á la variable. L'initialisation d'une variable est donc toujours nécessaire. Elle peut se faire via une instruction d'affectation.

2.4. Record á champ variant (cfr Ch 2.2.2)

Une variable de type record á champ variant est une variable dont la structure est influencée par la valeur que prend un de ses champs. La structure dépend de la valeur affectée á ce champ.

    type fiche = record
         nom    : packed array [1..20] of char;
         prenom : char;
    case etranger : Boolean of
         true  : (nationalite : pays);
         false : (regimelinguistique : langue)
    end;
    var personne : fiche;

Si on affecte la valeur vrai au champ etranger de la variable personne, les champs accessibles de la variable sont : nom, prenom, etranger, nationalite.

Par contre, si on affecte la valeur faux au champ etranger de la variable personne, les champs accessibles de la variable sont : nom, prenom, etranger, regimelinguistique.

    type pays = (Belgique, France, Allemagne, Italie);
    type langue = (FR, NL, DE);

    var p1,p2 : fiche;

    begin
        ....
        p1.etranger := true;
        p1.nationalite := France;
        ... {p1.regimelinguistique n'a pas de sens}

        p2.nationalite := false;
        p2.regimelinguistique := NL;

        ... {p2.nationalite n'a pas de sens}

        {impression de la strucure}
        writeln(p1.nom,p1.prenom);
        if p1.etranger
            then writeln(p1.nationalite)
            else writeln(p2.regimelinguistique)
        ...
    end.

3. Instruction de branchement

L'instruction goto s'écrit

Effet : la prochaine instruction exécutée est celle qui est précédée par l'étiquette spécifiée (cfr Ch 8.1).

Remarques :

  1. Une instruction goto ne permet pas d'entrer á l'intérieur d'une instruction composée (ni a fortiori dans un bloc).
  2. En Turbo-PASCAL, une instruction goto ne permet pas de sortir du bloc dans lequel elle se trouve. En particulier, on ne peut utiliser un goto pour passer d'un sous-programme au programme appelant.
  3. L'instruction goto est á utiliser avec réserve. Il convient de ne pas l'utiliser pour simuler une instruction répétitive (cfr Ch 8.5) , mais éventuellement lorsque l'écriture du programme s'en trouve clarifiée, notamment pour quitter une instruction répétitive admettant diverses conditions de sortie qui peuvent être vérifiées á différents endroits de la boucle.
Exemple

Vérification de l'appartenance d'un entier e á un tableau a : array [1..N] of integer, en parcourant séquentiellement le tableau.

  1. version sans goto :
        trouve := false;
        i := 1;
        while (i <= n) and not trouve do
            if a[i] = e then trouve := true
                        else i := i + 1;
        writeln (trouve);
     
  2. version avec goto :
        trouve := false;
        for i := 1 to n do
            if a[i] = e then
            begin
                trouve := true;
                goto 999
            end ;
        999: writeln (trouve);
       
  3. une dernière version consiste á remplacer le while de la version (a), ou le for de la version (b), par un if... then... else avec un goto. Cette pratique est á proscrire absolument !

4. Instructions conditionnelles

Le PASCAL possède deux instructions conditionnelles : if et case.

4.1. Instruction if


Effet : l'instruction1 est exécutée si la condition expression est vraie; l'instruction2, si elle apparaît, est exécutée si la condition expression est fausse. Il faut que expression soit booléenne.

Remarques :

4.2. Instruction case ... of


expression et constante sont de type T avec T un type simple autre que real.

La même constante ne peut apparaître deux fois dans une instruction case.

Effet : seule l'instruction en regard de l'expression constante est exécutée. Après l'exécution de cette instruction, l'instruction case est terminée : on passe donc á l'instruction suivante.

Le PASCAL standard ne reconnaît pas de cas par défaut (c'est­á­dire une instruction á exécuter si l'expression n'égale aucune des constantes) : cette situation donne lieu á une erreur.

Toutefois, le PASCAL­UVA accepte la clause otherwise en fin d'instruction case comme instruction par défaut.

Il faut noter l'absence de ":" après le mot­clé otherwise.

    type days = (monday,tuesday,wednesday,thursday,friday,saturday,sunday);

    var x    : integer ;
        jour : days;
        ...

    case jour of
        saturday,sunday:   
        begin
            .
            .
            .
        end;
        monday:          x := x + 1;
        tuesday,thursday:  ; {instruction vide}
        wednesday,friday:  begin
            .
            .
            .
        end
    end  {case jour} ;

    x := x + 4;
    ...

    case jour of
        saturday, sunday: writeln('pas de cours');
        wednesday: writeln('cours l''avant-midi');
        otherwise writeln('cours toute la journee')  {uniquement PASCAL-UVA}
    end  {case jour};
    ...


5. Instructions de répétition.

Le langage PASCAL offre trois instructions de répétition : while, repeat et for.

5.1. Instruction while ... do



expression est une expression booléenne.

Effet : Tant qu'expression a la valeur "vrai", on exécute l'instruction.

5.2. Intruction repeat ... until



expression est une expression booléenne. Effet : la suite d'instructions est exécutée, puis tant que l'expression booléenne est fausse, la suite d'instructions est á nouveau exécutée (c'est­á­dire jusqu'á ce que expression soit vraie). L'instruction est donc exécutée au moins une fois.

5.3. Instruction for ... do


Les deux valeurs (valeur initiale et valeur finale) sont deux expressions dont le résultat doit être affectable á la variable. Ce type doit être un type simple, sauf real.

Effet : la valeur initiale et la valeur finale sont calculées une fois pour toute au début de l'instruction for. Ensuite, l'instruction est exécutée pour toutes les valeurs scalaires comprises entre valeur initiale et valeur finale, en ordre croissant (to) ou en ordre décroissant (downto). Dans le premier cas, si la valeur finale est inférieure á la valeur initiale, l'instruction n'est pas exécutée. Dans le second cas, il en est de même si la valeur finale est supérieure á la valeur initiale.

Notes importantes :

  1. La variable doit être locale (cfr Ch 13.2).
  2. La variable ne peut pas être modifiée dans le corps de la boucle (c'est­á­dire dans l'instruction); en particulier, elle ne peut pas être passée par adresse (cfr Ch 11.2) á un sous­programme. De plus, la valeur de la variable est indéfinie á la sortie de la boucle.
  3. La valeur initiale et la valeur finale peuvent être modifiées dans le corps de la boucle; ceci ne change pas pour autant le nombre de fois que l'instruction sera exécutée.

6. Instruction with

L'instruction with fournit une économie d'écriture en permettant á un utilisateur de ne spécifier qu'une fois le nom de variables de type record (dans l'en­tête d'instruction) au lieu de les spécifier chaque fois qu'un champ de la structure est utilisé.

Exemple: Les instructions

    UneAuto.annee := 1979 ;
    UneAuto.couleur := bleu ;
    UneAuto.marque := 'DATSUN CHERRY GL    ' ;
peuvent être remplacées par
    with UneAuto do
    begin
        annee := 1979 ;
        couleur := bleu ;
        marque := 'DATSUN CHERRY GL    '
    end{with UneAuto} ;
Lorsque plusieurs variables sont spécifiéees dans l'en­tête d'instruction, l'instruction
    with v1, v2, ..., vn do S ;
est équivalente á
    with v1 do
        with v2 do
            ...
            with vn do S ;

Table des matières indexe chapitre suivant