Vous êtes sur la page 1sur 27

Fichiers Textes

Fichiers binaires

Mme. Jinène Moslah

1
En C, les communications d‟un programme avec son environnement se font
par l‟intermédiaire de fichiers.
Même le clavier et l‟écran sont des fichiers dits « standards ».

Jusqu‟à maintenant, les données traitées dans un programme sont perdues


à la fin de l‟exécution du programme. On peut remédier à ceci en stockant
les données sur des unités de stockage permanent.

Nous pouvons donc créer, lire ou écrire dans des fichiers de différents
périphériques .

2
 La gestion de fichiers en c est assurée par la librairie standard
<stdio.h> via un ensemble de fonctions commençant par la
lettre “f”

Avant de manipuler un fichier, il faut lui associer


un descripteur (pointeur vers la structure fichier)

 Déclaration :

FILE *f;
Un fichier f possède une position de début, une position de fin
et une position courante, stockés dans la structure de type FILE

Chaque opération sur un fichier est effectuée sur les données en position
courante.

Les données sont stockées consécutivement selon l‟ordre


d‟entrée et peuvent seulement être lues dans cet ordre.

Fichier séquentiel :

4
 Les fichiers sont ouverts avec la fonction fopen
ils sont fermés avec la fonction fclose
FILE* fopen(const char* nomf, const char* mode);
int fclose (FILE *f);

 le nom du fichier nomf est le nom classique (relatif ou absolu),


par exemple : " test.txt " ou " C:\\CoursC\\test.txt "
 Attention, en C, au caractère \ dans les chaînes de
caractère ! Écrire \\
"C:\\CoursC\\test.txt"
fopen nous permet d‟établir un lien entre le chemin d‟accès au fichier sur
le support externe

Exemple :
FILE * pFichier = NULL;
pFichier = fopen(" C:\\MesDocuments\\Fiches.txt", "r");

Nom du Chemin d‟accès Mode d‟accès :


fichier au fichier sur - lecture ("r"),
logique support externe - écriture ("w"),
(pointeur - concaténation ("a"):
de fichier) écrire à la fin du fichier.

La commande fopen renvoie un pointeur vers une structure de type FILE


renfermant : - l‟adresse de la mémoire tampon,
- la position courante,
- le mode d‟accès, etc.
6
Tout ce que nous avons à faire dans notre programme est :

déclarer un pointeur de type FILE * pour chaque fichier dont nous avons
besoin,
affecter l‟adresse retournée par fopen à ce pointeur,
employer le pointeur à la place du nom du fichier dans toutes les
instructions de lecture ou d‟écriture,
libérer la mémoire tampon et annuler la liaison entre le pointeur et le nom
du fichier à la fin du traitement à l‟aide de fclose :
int fclose(pFichier);
fclose retourne EOF si une erreur est survenue; 0 autrement.
Ouverture en écriture : les données non écrites de la mémoire tampon sont écrites.
Ouverture en lecture : les données non lues de la mémoire tampon sont perdues.
 Si le fichier n'est pas ouvert correctement, inutile de continuer le
programme  Testez systématiquement la valeur du descripteur de
fichier juste après fopen

#include <stdio.h> /* pour fopen également*/


void main()
{
FILE *monfic;
monfic=fopen("test.txt","r"); /* r : Read Mode */
if (monfic==NULL) /* test de l'ouverture */
{ printf(« ERREUR : fichier non ouvert !\n"); }
else
{ /* suite du programme */
fclose (monfic);
}
}
 "r " : Ouverture du fichier en lecture. présuppose que le
fichier existe déjà. Si le fichier pas n‟existe, fopen() renvoie
NULL.

 "w " : Ouverture du fichier en écriture. Si le fichier n‟existe


pas, il est créé. S‟il existe déjà, son contenu est effacé.

 "a " : Ouverture du fichier en mise à jour (append). Si le


fichier n‟existe pas, il est créé. S‟il existe déjà, les nouvelles
informations sont ajoutées à la fin.
 "r+ " : Ouverture en lecture et en écriture. les nouvelles informations
sont écrites en tête, écrasant celles qui s‟y trouvaient précédemment.

 "w +" : lecture et écriture, avec suppression du contenu au préalable. Le


fichier est donc d'abord vidé de son contenu, vous pouvez y écrire, et le
lire ensuite. Si le fichier n'existe pas, il sera créé.

 "a +" : Ouverture du fichier en mise à jour (append). Si le fichier n‟existe


pas, il est créé. S‟il existe déjà, les nouvelles informations sont ajoutées à
la fin.
NB: si on ajoute un "b " après le premier
caractère : "rb", "wb", "ab", "rb+", "wb+",
"ab+", alors le fichier est ouvert en mode
binaire.
Opération d‟écriture la plus simple : fputc
Écriture d‟un caractère représenté par c dans un fichier décrit par pFichier.
int fputc(int c, FILE * pFichier);
Si l‟opération d‟écriture est réussie, fputc retourne le caractère c;
autrement, le caractère spécial EOF.

Opération de lecture la plus simple : fgetc


Lecture d‟un caractère dans un fichier décrit par pFichier.

int fgetc(FILE * pFichier);


Si l‟opération de lecture est réussie, fgetc retourne le caractère lu comme
une valeur de type int; autrement, le caractère spécial EOF est retourné.
11
#include <stdio.h>
#include <string.h>

void main()
{
char chaine[80];
int i;
int c;
// Création d'un fichier.

FILE * pFichier = NULL;

pFichier = fopen("Exp1.txt", "w");

// Saisie au clavier d'une chaîne de caractères.

printf("Entrez une chaine de caracteres :");


scanf("%s", &chaine);
12
// Écrire dans le fichier la chaîne de caractères inversée.

for (i = strlen(chaine) - 1; i >= 0; i--) fputc(chaine[i], pFichier);

fclose(pFichier); // Fermeture du fichier ouvert en écriture.

// Ouverture d'un fichier en lecture.

pFichier = fopen("E:\\Nouveau_dossier\\Exp1.txt", "r");

// Lecture de chaque caractère du fichier et affichage à l'écran.

c = fgetc(pFichier);
while (c != EOF)
{
printf("%c", c);
c = fgetc(pFichier);
}
printf("\n");
fclose(pFichier); // Fermeture du fichier ouvert en lecture.
13
Opération d‟écriture : fputs
Écriture d‟une chaîne pointée par pChaine dans un fichier décrit par pFichier.
int fputs(char * pChaine, FILE * pFichier);
La copie s‟effectue jusqu‟à ce que l‟on rencontre le caractère '\0'.
Si l‟opération d‟écriture n‟est pas réussie, fputs retourne le caractère EOF.

Opération d‟écriture : fgets


Lecture des Nb_de_caracteres -1 prochains caractères d‟un fichier décrit
par pFichier pour les ranger dans une chaîne pointée par pChaine .

char * fgets(char * pChaine, int Nb_de_caracteres, FILE * pFichier);

14
#include <stdio.h>
void main()
{
char chaine[10]= "\0" ; char Fin = „O‟;
// Création d'un fichier.
FILE * pFichier = fopen("Exp2.txt", "w");
if (pFichier !=NULL) {
printf(« Ouverture du fichier en mode ecriture \n");
printf("Desirez-vous poursuivre (O ou N) ?"); scanf("%c", &Fin);
while (Fin == 'O')
{ // Saisie au clavier d'un nom.
printf("Entrez un nom : "); scanf("%9s", chaine);
// Écrire le nom dans le fichier.
fputs(chaine, pFichier);
printf("Desirez-vous poursuivre (O ou N) ?");
scanf("\n%c", &Fin);
}
fclose(pFichier); // Fermeture du fichier ouvert en écriture.

}
15
// Ouverture d'un fichier en lecture.

pFichier = fopen("Exp2.txt", "r");

// Lecture de chaque nom du fichier et affichage à l'écran.


if (pFichier !=NULL)
{
while(fgets(chaine, 10, pFichier) != NULL)
printf("\n%s", chaine);

fclose(pFichier); // Fermeture du fichier ouvert en lecture.


}

16
typedef struct /* Lecture du fichier par fgets+sscanf (la fin de
{ fichier est atteinte quand fgets renvoie NULL) : */
char nom[20]; while ( fgets( ligne, 81, fic) != NULL )
short int jour; {
char mois[10]; if (sscanf(ligne,"%s%hd%s%hd", pers.nom,
short int annee; &pers.jour, pers.mois, &pers.annee) == 4)
} T_ANNIV; /* on s'assure de la validité des 4 données */
void main(void) {
{ printf("\n nom: %s ", pers.nom ) ;
FILE* fic ; printf("\n date naiss: 2hd%s%hd\n",pers.jour,
char ligne[81]; pers.mois, pers.annee);
T_ANNIV pers; }
/* Ouverture du fichier (en lecture texte) : */ else
fic = fopen("essai.txt", "r") ; puts("Pb de lecture avec sscanf (format de
if (fic==NULL) ligne incorrect ?)") ;
{
puts("Pb d'ouverture du fichier essai.dat !"); }
exit(0); fclose( fic ) ;
} }
Opération d‟écriture : fprintf

Semblable à printf avec le pointeur fichier comme 1er argument.

Ex. : fprintf(pFichier, "%12d\n%12d\n%14f\n", int1, int2, reel1);

Opération de lecture : fscanf

Semblable à scanf avec le pointeur fichier comme 1er argument.


Ex. : fscanf(pFichier, "%12d\n%12d\n%14f\n", &int1, &int2, &reel1);
Retourne EOF si une erreur est commise; le nombre de données lues
autrement.

La fonction feof (pFichier) permet de tester si EOF ou non


void main (void)
{
FILE* fic ;
int i, tab[5] = {1,2,3,4,5 } ;
/* Ouverture du fichier (en écriture texte): */
fic = fopen( "resultat.dat", "w");
if (fic==NULL)
{
printf("\n\n Ouverture du fichier impossible !");
exit(0);
}
/* Ecriture dans le fichier : */
fprintf( fic, "Nombre d'elements : %d", 5 );
for (i=0; i<5; i ++) fprintf( fic, "\n element %d : %d", i, tab[i] );
/* la disposition dans le fichier texte sera comme à l'écran avec printf */
/* Fermeture du fichier : */
fclose( fic ) ;
}
void main (void)
{
FILE* fic ;
int i, i_lu, n, tab[5];
/* Ouverture du fichier (en lecture texte) : */
fic = fopen( "resultat.dat", "r") ;
if ( fic==NULL )
{ printf("\n\n Ouverture fichier impossible !"); exit(0); }

/* Lecture du fichier (remarque : feof(fic) vaut 0 (faux) si fin de fichier non atteinte) : */
fscanf( fic, "Nombre d'elements : %d", &n );
for ( i=0 ; (i<n) && (!feof(fic)) ; i ++ )
fscanf( fic, "\n element %d : %d", &i_lu, &tab[i] );
/* Traitement des données lues : */
printf("\n\n Voici les valeurs lues dans le fichier :");
for (i=0; i<n; i ++) printf( "\n element %d : %d", i, tab[i] );
puts("\n\n");
/* Fermeture du fichier : */
fclose( fic ) ;
}
crée le vide le position du
mode lecture écriture
fichier fichier flux

r X début
r+ X X début
w X X X début
w+ X X X X début
a X X fin
a+ X X X fin
21
 Les fichiers binaires permettent des entrées/sorties de données
au format interne de la machine.

 Les accès sont considérablement plus efficaces que pour des


entrées/sorties formatées

22
 L‟ouverture d‟un fichier binaire se fait en ajoutant le spécificateur b
au mode d‟ouverture de l‟appel fopen
 Les accès se font via deux fonctions, fread et fwrite, avec une
interface banalisée :

int fread ( void* adr, int taille_element, int nb_elements, FILE* fic);
int fwrite ( void* adr, int taille_element, int nb_elements, FILE* fic);

 Pour les tailles des données à lire ou écrire, il est conseillé d‟utiliser
systématiquement l‟opérateur sizeof.

23
double x, y;
float tab[50];
FILE *fi, *fo;
fi = fopen("data.bin", "rb");
fo = fopen("result.bin", "wb");
/* Lecture sur ‟fi‟ de 2 scalaires */
fread(&x, sizeof(double), 1, fi);
fread(&y, sizeof(double), 1, fi);
/* Ecriture sur ‟fo‟ d‟un tableau */
fwrite(tab, sizeof(float), 50, fo);
24
#include <stdio.h>
#include <stdlib.h>
#define DIM 100
void main() {
int i;
double sum,tab1[DIM],tab2[DIM];
FILE *fichier;
//Remplir un tableau
for(i=0;i<DIM;i++) tab1[i]=i;
// Ecriture du fichier au format binaire
fichier = fichier = fopen("explefbinaire.bin","wb");
if (fichier != NULL)
{ fwrite(tab1,sizeof(double),DIM,fichier);
fclose(fichier);
}
// Lecture du fichier
fichier = fichier = fopen("explefbinaire.bin","rb");
if (fichier != NULL)
{
fread(tab2,sizeof(double),DIM,fichier);
//afficher pour tester
puts("le fichier contient: \n");
for(i=0;i<DIM;i++) printf("\t%lf", tab1[i]);

fclose(fichier);
}
}
 si on veut se positionner en un point quelconque du fichier sans
lire ce qui précède, afin d'accéder à une donnée particulière, la
lecture séquentielle ne convient plus : il faut un accès direct (ou
non séquentiel).

 Celui‐ci est obtenu en utilisant la fonction de


positionnement fseek avant d'effectuer la lecture par fread.

 Accès à éviter

int fseek (FILE *Stream, long Offset, int Origin);