Vous êtes sur la page 1sur 10

Chapitre 7: Les fichiers

I/ Introduction :

Alors que le tableau a une taille fixe, le fichier lui est a priori illimité.
Aussi, les données sauvegarder dans un tableau, sont volatiles, c'est-à-dire elles
sont perdues à la fin de l’exécution du programme alors que les données
sauvegarder dans un fichier sont permanentes.

II/ Définition :
Un fichier (en anglais : File) est un ensemble structuré de données stocké sur un
support externe (disquette, disque dur, flash disque …).

Les avantages des fichiers sont : - Taille non limitée


- Sauvegarde permanente.

On distingue deux techniques de gestion de fichiers :

1- L’accès séquentiel consiste à traiter les informations « séquentiellement »,


c'est-à-dire dans l’ordre où elles apparaissent dans le fichier. Si on a besoin
d’un élément précis dans un fichier séquentiel, il faut lire tous les éléments qui
le précèdent, en commençant par le premier élément.
2- L’accès direct consiste à se placer immédiatement sur l’information souhaitée,
sans avoir à parcourir celles qui la précèdent.

(Dans ce cours nous ne considérons que les fichiers à accès séquentiel).

Nous supposons que tout fichier peut être schématisé par un ruban défilant devant
une tête de lecture/écriture qui permet de se positionner sur l’élément à lire ou à
écrire. On n’a accès à une valeur que si l’élément correspondant, appelé l’élément
courant, est en face de la tête de lecture/écriture.

Tête de
lecture/Ecriture Sens de défilement

… 12 56 -8 22 37 125 637 -45 0 110


...

III/ Définition du type fichier :


Les fichiers peuvent contenir des données de différents types simples ou structurés,
mais toutes les données sont du même type.
Pour pouvoir traiter les éléments contenus dans un fichier on utilise :
- Une variable en mémoire qui représente le fichier à manipuler dans
l’algorithme (programme).
- Une autre variable qui représente l’élément et qui s’appelle une variable
tampon

Dans un ordinateur, tout fichier est identifié :

- au niveau du système d’exploitation (exemple : WINDOWS, UNIX, MS-DOS…)


par un nom physique, qui est une chaîne de caractères ;
- au niveau du langage de programmation (exemple : Pascal, C) par un
identificateur ou nom logique, comme toute autre variable. Le type de cet
identificateur sera défini comme fichier de <type_éléments> où <type_éléments>
est le type des éléments du fichier.

Nom interne Nom externe ou


ou logique F Fich.Dat physique c-à-d
le nom réel sur
le support

Mémoire Centrale Unité de stockage

III.1/ Déclaration :
La syntaxe de la déclaration est la suivante

Var
<identificateur_fichier> : fichier de <type_elements> ;

<type_éléments> peut être n’importe lequel des types présentés antérieurement.

Exemple :

Type
objet=enregistrement
X : réel ; Y : caractère ;
Fin_enregistrement ;

Tab=tableau [1..10] d’entier ;


Var
F1 : fichier de réel ; x1 :reel ;
F2 : fichier de tab ; t :Tab ;
F3 : fichier de objet ; o :objet ;

III.2/ La mémoire tampon :


Les accès à un fichier se font par l’intermédiaire d’une variable appelée « mémoire
tampon » (anglais : buffer). Cette variable est du même type que les éléments du
fichier c-à-d <type-element> et elle peut être simple ou structurée.
Exemple :

Type
tab=tableau [1..10] d’entier ;

Var F : fichier de tab ;


X : tab ; {mémoire tampon}

III.3/ Instructions de manipulation des fichiers :


III.3.1/ Assignation :

C’est la première opération à réaliser sur un fichier. Elle permet de définir le nom
physique sous lequel le fichier sera sauvegardé sur l’unité de stockage.

Syntaxe : Assigner (<nom_logique>, <nom_physique>) ;

Nom_logique : désigne le nom du fichier choisi dans la déclaration ( la var.


mémoire manipulée).
Nom_physique : désigne une chaîne de caractère qui peut être soit une variable ou
une constante de type chaîne.

Exemples :

1) Var F1 : fichier de réel;


Nom_fichier : chaîne ;
Début
Ecrire (‘donner le nom du fichier’) ;
Lire (Nom_fichier) ;
Assigner (F1, Nom_fichier) ;
…..
Fin.

2) Var F1 : fichier de réel ;


Début
Assigner (F1,’liste_etudiants’) ;
Ou bien
Assigner (F1, ‘C:\ LMD_MI\ Algo\liste_etudiants’) ;
……
Fin.

III.3.2/ Fonction de fin de fichier :

Un fichier n’est défini que s’il comporte une marque de « fin de fichier » qui permet
de tester si la tête de lecture /écriture se trouve à la fin du fichier ou non.

Syntaxe : fdf (nom de fichier)


fdf une fonction booléenne qui retourne la valeur vrai si on a atteint la marque de fin
de fichier, dans le cas contraire elle retourne la valeur faux.

L’entête de la fonction fdf est donné par :

fonction fdf (E/ f :fichier de <type_éléments>) :booleen ;

Exemple :

Var F : fichier d’entier ;



Tantque (fdf(F)=faux) faire

Fait ;

III.3.3/Accès au premier élément (ouverture en lecture):

Pour ouvrir un fichier en lecture et accéder au premier élément s’il existe, on utilise :

Syntaxe : Relire(nom de fichier) ;

Cette action(ou primitive) positionne la tête de lecture/écriture en face du premier


élément du fichier pour permettre sa lecture.
Dans le cas d’un fichier non vide, la fonction fdf retourne la valeur faux.
Dans le cas d’un fichier vide, la fonction fdf retourne la valeur vrai.

L’entête de la procédure Relire est donné par :

Procedure Relire (E/ f :fichier de <type_éléments>) ;

III.3.4 / Accès à l’élément courant :

Pour accéder à l’élément courant on utilise l’instruction Lire

Syntaxe : Lire(nom de fichier,val) ;

Cette primitive permet d’accéder à la valeur de l’élément courant et de sélectionner


l’élément suivant. Elle provoque dans l’ordre :

- la copie de l’élément courant pour le mettre dans val,


- l’avancement de la tête de lecture/écriture d’une position. Si la marque de fin de
fichier est alors sélectionnée alors fdf(nom de fichier) prend la valeur vrai sinon
elle conserve la valeur faux.

Cette primitive ne peut pas être utilisée si l’on atteint la fin de fichier (fdf=vrai)

L’entête de la procédure Lire est donné par :


procedure Lire (E/ f : fichier de <type_éléments> ;E_S/ val :<type_éléments>) ;

Exercice 1:
Soit F un fichier d’entier, calculer la somme des éléments de F.
Algorithme Somme ;
Var
F :fichier d’entier ;
Som,x :entier ;
nom :chaine ;
Debut
Som0 ; lire(nom) ;
Assigner(F,nom) ;
Relire(F) ;
Tantque(fdf(F)=faux) faire
Lire(F,x) ;
SomSom+x ;
Fait ;
Ecrire(som) ;
Fermer(F) ;
Fin.

Exercice 2 :
Ecrire un algorithme qui permet d’afficher les nombres pairs d’un fichier d’entiers F.
Algorithme pairs ;
Var
F :fichier d’entier ; x :entier ;
nom :chaine ;
debut
lire(nom) ;
Assigner(F,nom) ;
Relire(F) ;
Tantque non fdf(F) faire
Lire(F,x) ;
Si x mod 2=0 alors
Ecrire (x) ;
Fsi ;
Fait ;
Fermer(F) ;
Fin.

III.3.5/ Création d’un fichier vide (ouvrir un fichier en écriture):

Pour créer un fichier vide, on utilise la procédure : Recrire sa syntaxe est

Syntaxe : Recrire (nom de fichier) ;

Cette primitive permet de créer un fichier vide ayant pour nom « nom de fichier » à la
suite de son exécution, la fonction fdf(nom de fichier) retourne la valeur vrai.
Si le fichier contient au préalable des informations, il devient vide et toutes les
informations seraient perdues.

L’entête de la procédure Récrire est donné par :

Procedure Recrire (E_S/ f :fichier de <type_éléments>) ;

III.3.6/ Ajout d’un élément :

Pour ajouter un élément dans un fichier on utilise la primitive Ecrire sa syntaxe est :

Syntaxe : Ecrire (nom de fichier, val) ;

Cette primitive ne peut être utilisée que si la tête de lecture/écriture est positionnée
en fin de fichier (fdf=vrai). Elle provoque dans l’ordre :

- la recopie en fin de fichier, de la valeur contenue dans la variable val,


- Avancement du ruban d’une position, afin de positionner la tête d’écriture sur la
marque de fin de fichier,
- Après exécution, la fonction fdf retourne la valeur vrai

L’entête de la procédure Ecrire est donné par :

Procédure Ecrire (E_S/ f :fichier de <type_éléments>, E/ val :<type_éléments>);

Exemple :
Assigner(f,’fich.dat’) ;
Recrire(f) ;
Ecrire(f,10);
Ecrire(f,3);
Lire(x) ;
Ecrire(f,x);

///

10 ///

10 3 ////

X=15
10 3 15 ////
III.3.7/ Fermeture d’un fichier :

Syntaxe : Fermer (nom de fichier) ;

Cette instruction :
- garantit qu’il n’y a plus de données, du fichier, restées en mémoire
- réduit le nombre de fichiers ouverts à cet instant.

De plus, le fichier étant fermé, nous pouvons aussi le ré ouvrir, en l’associant à un


autre fichier sur l’unité de stockage.

Il est donc prudent de fermer le fichier dès qu’on a plus besoin d’y accéder.
Il est impératif de fermer tous les fichiers avant de quitter le programme.

****************************************************************

III.4/ Fichier paramètre d’une procédure :

Un fichier peut être un argument d’une procédure. Le paramètre correspondant est


déclaré sous la forme :

Procedure nom(E-S/ F :type_fichier ;…) ;


Si le fichier est retourné comme résultat.

Où type_fichier est un identificateur défini dans une déclaration spécifique, la


déclaration de Type est comme suit :

Type type_fichier=fichier de <type> ;

III.5 Exemples

Exercice 1 : écrire une AP qui retourne la somme des éléments d’un fichier f de
nombres entiers.
Type
Fichent=fichier d’entier ;
Fonction somme_fichier(E/ f :Fichent) :entier ;
Var
som,c :entier ;
debut
Relire(f) ; som 0 ;
Tant que non fdf(f)
Faire
Lire (f,c) ;
som som+c ;
Fait ;
Fermer(f) ; somme_fichier som ;
Fin ;
Exercice 2 : écrire une AP qui permet de retourner la valeur maximale contenue
dans un fichier f de nombres entiers.

Fonction maximum(E/ f :Fichent) :entier ;


Var
max,c :entier ;
Debut
Relire(f) ;
Lire(f,max);
Tant que non fdf(f)
Faire
Lire (f,c) ;
Si (max<c) alors
maxc ;
Fsi ;
Fait ;
Fermer(f) ;
maximummax ;
Fin ;

Exercice 3 : écrire une AP qui permet de vérifier l’existence d’une valeur val dans un
fichier f de nombres entiers.

Fonction existence(E/ f :Fichent ; val :entier):booleen ;


Var
c :entier ;
trouve :booleen ;
debut
Relire (f) ; /* si fdf(f)=vrai ou si fdf(f) */
si fdf (f) alors trouve faux /* si fdf(f)=faux ou si non fdf(f)*/
sinon
Lire (f,c) ;
Tant que non fdf(f) et (c<>val) Faire
Lire (f,c) ;
Fait ;
Si (c=val) alors trouve vrai
Sinon trouve faux ;
Fsi ;
Fsi ;
Fermer(f) ;
existence  trouve ;
Fin ;
2eme solution .
Fonction existence(E/ f :Fichent ; val :entier):booleen ;
Var
c :entier ;
trouve :booleen ;
debut
Relire (f) ;
si fdf (f) alors trouve faux
sinon
trouvefaux ;
Tant que non fdf(f) et trouve=faux Faire
Lire (f,c) ;
Si c=val alors trouvevrai ; fsi ;
Fait ;
Fsi ;
Fermer(f) ;
existence  trouve ;
Fin ;

**************************************************************

Exercice 4 : écrire une AP qui permet de créer par recopie (à partir d’un autre fichier)
d’un fichier d’entiers.

Procedure copie (E/ f :fichier d’entier ; E-S/ g : fichier d’entier) ;


Var
c :entier ;
debut
Recrire (g) ;
Relire (f) ;
Tant que non fdf(f)
Faire
Lire (f,c) ;
Ecrire (g,c) ;
Fait ;
Fermer(f) ; Fermer(g) ;
Fin ;

Exercice 5: Eclatement d’un fichier d’entiers en deux fichiers suivant le critère de


parité :

Procedure éclater (E/ f : fichier d’entier ; E_S/ fpair,fimpair : fichier d’entier) ;


Var
c :entier ;
debut
Relire(f) ;
Recrire (fimpair) ;
Recrire (fpair) ;
Tant que non fdf(f) Faire
Lire (f,c) ;
Si c mod 2=0 alors
Ecrire (fpair,c)
Sinon écrire (fimpair, c) ;
Fsi ;
Fait ;
Fermer(f) ; Fermer(fpair) ; Fermer(fimpair) ;
Fin ;

Exercice 6 : écrire une AP qui permet de faire l’Interclassement (ou fusion) de deux
fichiers d’entiers triés en un fichier trié f :

Vous aimerez peut-être aussi