Table des matières indexe chapitre suivant

Chapitre 10 : Instructions et expressions d'Entrée/Sortie

Tables des matières


0. Introduction

On peut ranger les instructions et les expressions d'entrée/sortie en 3 catégories :


1. File of ...

1.1. Initialisation

Comme toute variable, une variable de type file of T (cfr Ch 5.3) doit être initialisée. L'initialisation d'une telle variable a pour but d'ouvrir le fichier et de spécifier l'emploi ultérieur qui en sera fait : soit la lecture de données, soit l'écriture des résultats. Il n'est donc pas possible d'écrire dans un fichier ouvert en lecture ou de lire dans un fichier ouvert en écriture. Il n'est pas non plus possible d'ouvrir un fichier á la fois en lecture et en écriture, ce qui est une limitation du PASCAL. En Turbo-PASCAL, il faut avant tout établir une association entre un nom de fichier logique, utilisé dans le texte du programme et un nom de fichier physique, qui est le nom du fichier sur le disque. ( Dans les autres compilateur PASCAL, le nom logique et le nom physique sont les mêmes ). Cette association se fait au moyen de l'instruction :

Les instructions d'initialisation d'un fichier f de type file of T sont les suivantes :

1.2. Lecture : instruction read(f,x)

Lorsqu'un fichier f de type file of T a été ouvert en lecture au moyen de l'instruction

    reset(f)      ( ou aussi rewrite(f) en Turbo-PASCAL )
on peut en lire les éléments un á un par une successsion d'instructions
    read(f,x)
x est une variable de type T' et où T est affectable á T'. L'effet est de lire un élément du fichier et d'assigner la valeur lue á la variable x. Il est possible de lire plusieurs éléments par une seule instruction read á condition d'énumérer la liste des variables comme argument.

Exemple

        read(f,a,b,c)
    a le même effet que la suite d'instructions
        read(f,a);
        read(f,b);
        read(f,c);

1.3. Ecriture : instruction write(f,x)

Lorsqu'un fichier f de type file of T a été ouvert en écriture au moyen de l'instruction

    rewrite(f)      ( ou aussi rewrite(f) en Turbo-PASCAL )
on peut y écrire des éléments un á un par une succession d'instructions
    write(f,e)
e est une expression affectable á une variable de type T. En PASCAL standard, e peut être un expression; en Turbo-PASCAL, e ne peut être qu'une variable.

Exemples

    write(f,a+1)
    write(a)

Il est possible d'écrire plusieurs éléments par une seule instruction write.


Exemple
        write(f,a,b,c)
    a le même effet que la suite d'instructions :
        write(f,a);
        write(f,b);
        write(f,c);

1.4. Détection de la fin d'un fichier de données : eof(f)

Pour lire complètement un fichier de données f, il faut autant d'instructions

    read(f,x)
qu'il y a d'éléments dans le fichier. Le nombre d'éléments n'étant pas toujours connu á l'avance, il faut disposer d'un moyen de détection de fin de fichier. La fonction booléenne prédéfinie "end of file"
    eof(f)
renvoie la valeur vrai lorsque tous les éléments du fichier f ont été lus et renvoie faux autrement. En particulier, si le fichier f est initialement vide, eof(f) vaut vrai après l'initialisation du fichier par l'instruction reset(f). Toute tentative de lecture alors que eof(f) est égale á vrai se solde par une erreur á l'exécution et l'arrêt du programme.

Exemple

    reset(f);
    ...
    while not eof(f) do
    begin
        read(f,x);
        ...
    end;

1.5. Remarque importante

Soit f un fichier de type file of T où T est de type quelconque sauf char. Il n'est pas possible d'éditer, de visualiser ou d'imprimer un tel fichier. En effet, les éditeurs, les imprimantes et les terminaux manipulent uniquement des caractères. Or, un fichier file of integer ne contient pas de caractères, mais bien des nombres entiers représentés de façon binaire. C'est pourquoi on n'utilisera un fichier file of T (avec T char) que lorsque seuls des programmes PASCAL y accèdent en écriture ou en lecture. Tous ces programmes doivent déclarer le fichier f comme étant du type file of T. Dans tous les autres cas, on a recours aux fichiers de type text.


2. Text

Text est un type prédéfini (cfr Ch 2.2.4).

2.1. Organisation d'un fichier de type text

Un fichier de type text se compose d'une suite de lignes, chacune d'entre elles étant une suite de caractères. La fin d'une ligne est indiquée par le caractère spécial "retour chariot" (en anglais "carriage­return").

2.2. Initialisation

L'initialisation d'un fichier de type text suit le schéma d'initialisation d'un fichier de type file of T.
Pour rappel :

2.3. Lecture

2.3.1. Instruction read(f,x)
Lorsqu'un fichier f de type text a été ouvert en lecture au moyen de l'instruction
    reset(f)
on peut y lire les éléments un á un par une succession d'instructions
    read(f,x)
où, en PASCAL standard, x est une variable d'un des types simples sauf un type énuméré ou le type Boolean, c'est­á­dire : char, integer, real, intervalle (cfr Ch 2.1) ou un synonyme de ceux­ci (cfr Ch 4.3). Remarque : x ne peut donc pas être une chaîne de caractères (packed array [...] of char). Mais en Turbo-PASCAL, x peut être d'un type string ( cfr Manuel de Référence du Turbo-PASCAL).

Plus précisément,

Remarque : le PASCAL­UVA permet l'écriture de valeurs de type booléen. Les règles s'appliquant á la lecture d'un nombre sont d'application. Si une valeur lue n'appartient pas au type attendu, une erreur est générée. Les suites de caractères représentant les valeurs booléennes sont TRUE et FALSE (en majuscules).

Note importante : la différence de comportement avec la situation décrite au § 1.2 du présent chapitre peut être résumée comme suit :

2.3.2. Instruction readln(f)

L'effet de l'instruction

    readln(f)
est de forcer le passage á la ligne: tous les caractères, depuis celui qui suit le dernier caractère lu jusqu'au caractère retour chariot suivant, sont sautés, retour chariot compris. Ceci permet de se positionner au début de la ligne suivante.

2.3.3. Instruction readln(f,x)

L'instruction

    readln(f,x)
est équivalente á la suite d'instructions
    read(f,x);
    readln(f)

2.3.4. Lecture groupée

Il est possible de lire plusieurs éléments par une seule instruction read ou readln á condition d'énumérer la liste des variables comme argument.

Exemple

    read(f,a,b,c)
a le même effet que la suite d'instructions
    read(f,a);
    read(f,b);
    read(f,c);
et l'instruction
    readln(f,a,b,c)
a le même effet que la suite d'instructions
    read(f,a);
    read(f,b);
    readln(f,c);

2.4. Ecriture

2.4.1. Instruction write(f,x)

Lorsqu'un fichier de type text a été ouvert en écriture au moyen de l'instruction

    rewrite(f)
on peut y écrire des éléments un á un par une succession d'instructions
    write(f,e)
e est une expression de type char, integer, real, intervalle d'un de ces types, ou un packed array of char (cfr Ch 2.2.1.2) ou un synonyme de ceux­ci (cfr Ch 4.3). Plus précisément, l'expression est convertie en une suite de caractères représentant la valeur de l'expression; c'est cette suite de caractères qui est écrite dans le fichier.

Remarque : le Turbo-PASCAL permet l'écriture de valeurs de type booléen. Les suites de caractères représentant les valeurs booléennes sont True et False.

Exemple

    write(f,a+1) ;
    write(´Braine l´´Alleud´) ;
    write(f,b) ;
    write(f,sqrt(b)) ;
2.4.2. Instruction writeln(f)

L'effet de l'instruction

    writeln(f)
est de passer á la ligne suivante dans le fichier résultat (en fait, il y a écriture du caractère "retour chariot" dans le fichier).

2.4.3. Instruction writeln(f,x)

L'instruction

    writeln(f,x)
est équivalente á la suite d'instructions
    write(f,x);
    writeln(f)

2.4.4. Ecriture groupée

Il est possible d'écrire plusieurs éléments par une seule instruction write ou writeln á condition d'énumérer la liste des variables comme argument.

Exemple

    write(f,a,b,c)
a le même effet que la suite d'instructions
    write(f,a);
    write(f,b);
    write(f,c);
et l'instruction
    writeln(f,a,b,c)
a le même effet que la suite d'instructions
    write(f,a);
    write(f,b);
    writeln(f,c);

2.5. Détection de la fin d'un fichier de données : eof(f)

On utilise la fonction booléenne eof(f) comme décrit en Ch 10.1.4. Pour rappel, la fonction eof(f) renvoie la valeur vrai lorsque tous les éléments du fichier f ont été lus et renvoie faux sinon. En particulier, si le fichier f est initialement vide, eof(f) vaut vrai après l'initialisation du fichier par l'instruction reset(f). Toute tentative de lecture alors que eof(f) est égal á vrai se solde par une erreur á l'exécution du programme et un arrêt de celui­ci.

Exemple
Voici un exemple de fragment de programme correct:

    reset(f);
    ...
    while not eof(f) do
    begin
        read(f,x);
        ...
    end;

2.6. Détection de la fin d'une ligne : eoln(f)

La fonction booléenne "end of line"

     eoln(f) (où f est de type text)
renvoie la valeur vrai lorsque tous les éléments "utiles" d'une ligne ont été lus (c'est­á­dire lorsque le prochain caractère á lire est le caractère retour chariot) et renvoie la valeur faux autrement.
Il faut noter que si
    eof(f)  est vrai
alors
    eoln(f) est vrai également

( Ce comportement est propre au Turbo-PASCAL, en PASCAL standard, la valeur de eoln(f) devrait alors être indéfinie).

Exemple

    begin
        reset(f);
        while not eof(f) do
        begin
            while not eoln(f) do
            begin
                read(f,x);
                ...
            end; {while not eoln}
            readln(f) {lire le retour chariot}
        end; {while not eof}
    end;

2.7 Contrôle de l'impression

Le nombre de caractères écrits varie selon le type de la valeur écrite; en PASCAL­UVA, il varie de la manière suivante :

    char      1
    Boolean   4 si la valeur est TRUE
              5 si la valeur est FALSE
    integer   10
    real      15
    string    nombre de caractères du type

Il est possible, en PASCAL, de préciser explicitement le nombre de caractères á écrire lors d'un ordre write. Il faut, pour cela, faire suivre l'expression dont on veut imprimer la valeur de paramètres de contrôle, précédés du caractère ':'.
L'ordre d'écriture est alors

    write(fff,e:longueur)
ou
    write(fff,e:longueur:fract)   (uniquement pour le type real)
Les deux paramètres longueur et fract sont des nombres (valeurs ou identificateurs de constante) entiers positifs.
longueur représente toujours le nombre de caractères á écrire.


3. Entrée/Sortie standard : input et output

Les fichiers de nom input et output représentent respectivement l'entrée et la sortie standard (cfr Ch 5.3). Ces fichiers sont en fait de type text. Lorsqu'on souhaite les utiliser, ils doivent figurer dans l'en­tête mais ne doivent pas être déclarés dans la partie déclaration de variables.

3.1. Initialisation

Contrairement aux autres fichiers, il n'est pas nécessaire d'initialiser les fichiers input et ouput, ceux­ci l'étant d'office au début de l'exécution du programme.

3.2. Lecture, écriture, détection de fin de ligne et de fin de fichier

Les instructions de lecture sont

    read(x)         (lecture d'un élément)
    readln          (passage á la ligne)
    readln(x)       (combinaison des deux instructions précédentes)
    read(a,b,c)     (lectures groupées)
    readln(a,b,c)   (lectures groupées)

De même les instructions d'écriture sont :

    write(x)         (écriture d'un élément)
    writeln          (passage á la ligne)
    writeln(x)       (combinaison des deux instructions précédentes)
    write(a,b,c)     (écritures groupées)
    writeln(a,b,c)   (écritures groupées)
Elles ont le même effet que les instructions décrites en Ch 10.2.3 et Ch 10.2.4, ces dernières s'appliquaient au fichier de type text. A noter ici qu'on n'indique pas le nom du fichier utilisé en argument (par exemple, on n'écrit ni write(output,x), ni read(input,x)). Les fonctions booléennes de détection de fin de ligne et de fin de fichier sont
    eoln
    eof
Elles ont le même effet que celles décrites au Ch 10..2.5 et Ch 10.2.6. A noter ici qu'on n'indique pas non plus le nom du fichier input en argument.

Exemple

   begin
        while not eof do
        begin
            while not eoln do
            begin
                read(x);
                ...
            end; {while not eoln}
            readln
        end {while not eof}
    end;


4. Tableau récapitulatif.

          ___________________________________________________________________________
          |               | input            | text               | file of T        |
          |               | output           |                    |                  |
          |_______________|__________________|____________________|__________________|
          |le nom doit­il | oui              | oui (externe)      | oui (externe)    |
          |figurer        |                  |                    |                  |
          |dans l'en­tête |                  | non (interne)      | non (interne)    |
          |du programme ? |                  |                    |                  |
          |_______________|__________________|____________________|__________________|
          |le    nom   du | non              | oui                | oui              |
          |fichier  doit­ |                  |                    |                  |
          |il        être |                  |                    |                  |
          |déclaré ?      |                  |                    |                  |
          |_______________|__________________|____________________|__________________|
          |initialisation |                  | assign(f,'...')    | assign(f,'...')  |
          |du fichier     |                  | reset(f)           | reset(f)         |
          |               |                  | rewrite(f)         | rewrite(f)       |
          |_______________|__________________|____________________|__________________|
          |lecture        | read(x)          | read(f,x)          | read(f,x)        |
          |               | readln           | readln(f)          |                  |
          |               | readln(x)        | readln(f,x)        |                  |
          |               | read(a,b,...)    | read(f,a,b,...)    | read(f,a,b,...)  |
          |               | readln(a,b,...)  | readln(f,a,b,...)  |                  |
          |_______________|__________________|____________________|__________________|
          |écriture       | write(x)         | write(f,x)         | write(f,x)       |
          |               | writeln          | writeln(f)         |                  |
          |               | writeln(x)       | writeln(f,x)       |                  |
          |               | write(a,b,...)   | write(f,a,b,...)   | write(f,a,b,...) |
          |               | writeln(a,b,...) | writeln(f,a,b,...) |                  |
          |_______________|__________________|____________________|__________________|
          |test de fin de | eof              | eof(f)             | eof(f)           |
          |fichier        |                  |                    |                  |
          |_______________|__________________|____________________|__________________|
          |test de fin de | eoln             | eoln(f)            |                  |
          |ligne          |                  |                    |                  |
          |_______________|__________________|____________________|__________________|
où ``externe'' (resp. ``interne'') signifie ``pour les fichiers externes (resp. internes)''.


Table des matières indexe chapitre suivant