Next: La compilation et la correction des erreurs Up: Initiation au Langage Fortran Previous: Fonctions et subroutines

Sous-sections

Les fichiers

Avertissement : nous parlons ici implicitement de fichiers dits séquentiels, c'est-à-dire qu'à partir de l'ouverture du fichier, on lit les données dans l'ordre où elles sont stockées, sans pouvoir accéder directement à une donnée particulière. Au fur et à mesure des lectures ou écritures, un pointeur de fichier avance automatiquement d'une donnée à la suivante.

Il existe en FORTRAN des fichiers dits à accès direct, mais nous n'en parlerons pas ici.

Les fichiers séquentiels sont divisés en deux types : le fichiers formatés et les fichiers binaires.

Les fichiers formatés

Plus simplement, ce sont des fichiers texte, c'est-à-dire organisés en lignes de caractères, que l'on pourrait lire ou écrire avec un éditeur.

Lorsque l'on écrit un objet FORTRAN sur ce type de fichier, celui-ci est converti en chaîne de caractère selon un formatage défini par l'utilisateur ou par défaut (voir « Écritures formatées » 7.1)

Ce type de fichier est pratique car on peut les visualiser par un éditeur de texte, et de plus presque tous les logiciels savent lire des fichiers texte.

L'écran et le clavier sont des cas particuliers de fichiers formatés.

Les fichiers binaires

Les objets FORTRAN sont écrits sur ce type de fichier tels qu'ils sont stockés en mémoire. Par exemple, pour écrire un réel, on écrit directement les 4 octets constituant son codage en virgule flottante.

De ce fait, ce type de lecture/écriture est plus rapide et engendre des fichiers plus petits. L'inconvénient est que ces fichiers ne sont pas consultables par un éditeur de texte.

Ouverture d'un fichier

Il s'agit d'ouvrir un fichier déjà existant ou d'en créer un nouveau. Le FORTRAN associe au nom du fichier un entier appelé « unité », auquel toutes les instructions FORTRAN de manipulation des fichiers se référeront. Autrement dit le fichier n'est appelé par son nom qu'au moment de l'ouverture.

Syntaxe

`open(`	`numéro d'unité,`
	`file=chaîne de caractère,`
	`form=chaîne de caractères,`
	`status=chaîne de caractères,`
	`err=numéro de label`

Lors de l'ouverture d'un fichier, le pointeur de fichier est automatiquement placé avant la première donnée, sauf s'il est ouvert avec status='append'.

Description

Numéro d'unité

: tout entier compris entre 10 et 99. On peut également mettre une variable integer contenant cet entier.

file=

suivi d'une constante chaîne de caractère indiquant le nom du fichier en clair (par exemple '/home/louisnar/truc') ou bien une variable de type chaîne contenant le nom du fichier.

form=

chaîne de caractère pouvant être :

'formatted' ouvre ou crée un fichier formaté. C'est le défaut.
'unformatted' ouvre ou crée un fichier binaire.

status=

chaîne de caractère pouvant être :

'new' crée un nouveau fichier, ou génère une erreur s'il existe.
'old' ouvre un ancien fichier, ou génère une erreur s'il n'existe pas.
'unknown' ouvre le fichier quoi qu'il arrive. C'est le défaut.
'append' ouvre le fichier et se place automatiquement à la fin de celui-ci.

err=

numéro de label vers lequel le programme sera dérouté en cas d'erreur à l'ouverture.

Exemples

open(10,file='ethanol')

ouvre le fichier formaté ethanol du répertoire courant, qu'il existe ou non, et l'attache à l'unité 10.

      integer unite


      character*80 nomfich


      ...


      unite=10


      nomfich='ethanol'


      open(unite,file=nomfich)

fait la même chose que l'exemple précédent.

      character*80 nomfich


      


      nomfich='bidon.dat'


      


      open(10,file=nomfich,form='unformatted',


     &  status='new',err=99)


      ... ! (l'ouverture a réussi)


 99   write(*,*) 'Fichier ', nomfich,


     &  'deja existant'


      ...

essaye de créer un nouveau fichier binaire bidon.dat et affiche un message d'erreur au cas où ce fichier existe déjà.

Fermeture d'un fichier

C'est simple :

close(numéro d'unité)

Cette instruction détache le numéro d'unité du nom du fichier. Pour tout nouvel accès au fichier, il faut l'ouvrir à nouveau avec l'instruction open.

Notons que si le programme se termine normalement, tous les fichiers sont automatiquement fermés.

Lecture / Écriture sur un fichier

Syntaxe

`read(`	`numéro d'unité,`
	`format,`
	`err=numéro de label,`
	`end=numéro de label) liste de données`

`write(`	`numéro d'unité,`
	`format,`
	`err=numéro de label) liste de données`

Pour un fichier non formaté, on n'indique pas de format.
Pour un fichier formaté, on indique un format. Pour les lectures/écritures formatées, le format * est le format par défaut, les autres formats s'utilisent comme pour les écritures écran, lectures clavier (voir « formats d'écriture » 7.2).

Les autres paramètres optionnels sont :

err=numéro de label: En cas d'erreur, le programme est dérouté vers ce label.
end=numéro de label: Utilisable en lecture : lorsqu'on arrive à la fin du fichier, autrement dit quand il n'y a plus rien à lire, le programme est dérouté vers le label mentionné.

Remarque importante : Lorsque l'on effectue une instruction write dans un fichier séquentiel, toutes les données suivant la position courante du pointeur de fichier sont effacées.

Ainsi si l'on ouvre un fichier existant avec comme status 'old' ou 'unknown', et que l'on fait tout de suite un write, toutes les données seront effacées. Aussi, si l'on veut ajouter des données dans un fichier déjà existant, il faut l'ouvrir avec status='append'.

Exemples d'utilisation de fichiers

Affichage d'un fichier texte

Ouvrir le fichier texte truc.txt dont on ne connaît pas à priori le nombre de lignes et afficher à l'écran toutes les lignes de ce fichier texte (comme la commande cat UNIX).

C'est un cas exceptionnel ou on ne peut se passer de goto :

      character*80 ligne


      


      open(20,file='truc.txt')


      


 10   continue


      read(20,'(a)', end=99) ligne


      write(*,*) ligne


      goto 10


      


 99   continue


      end

Stockage de données (x,y)

Écrire une subroutine recevant en entrée deux vecteurs x et y double precision contenant n données chacun, et une chaîne de 80 caractères contenant un nom de fichier, qui écrit sur un fichier texte une valeur de x et une valeur de y par ligne.

      subroutine ecritxy (x, y, nomfich)


      character*80 nomfich


      double precision x(*), y(*)


      


      open(20,file=nomfich)


      


      do i=1,n


        write(20,*) sngl(x(i)), sngl(y(i))


      enddo


      


      close(20)


      return


      end

Pourquoi convertit on x(i) et y(i) en real avec la fonction sngl ? Tout simplement parce que lorsque le FORTRAN écrit une grandeur double precision avec le format *, celui-ci écrit un D à la place du E, par exemple : 1.345367222D-5 au lieu de 1.345367222E-5

Malheureusement la plupart des logiciels susceptibles de relire ce fichier (par exemple MATLAB) comprennent cette notation avec E mais pas avec D.

Exercice

On suppose que tout corps pur est déterminé par trois grandeurs que l'on appellera P_c, T_c et $\omega$ . Pour les besoins d'un programme, on veut se concocter une petite base de données, et pour chaque corps pur, à l'aide d'un éditeur on écrit en clair ces 3 valeurs sur 3 lignes d'un fichier texte. Par exemple, le fichier eau contiendra :

Écrire une subroutine recevant en entrée une variable chaîne contenant un nom de fichier, et fournissant en sortie :

les trois valeurs de P_c, T_c et $\omega$ lues sur le fichier,
un code d'erreur valant 0 si la lecture a réussi, -1 sinon.

Next: La compilation et la correction des erreurs Up: Initiation au Langage Fortran Previous: Fonctions et subroutines