FICHIERS

1
 Flots
• Flot = une suite d octets
• Les fichiers sont vus par le programmeur comme des
flots qui représentent des données selon une des deux
modalités suivantes :
– soit le fichier contient des caractères représentés suivant un
certain code (en général ASCII) → fichiers textes
– soit le fichier contient des données enregistrées sous une forme
qui est la copie exacte de leur codage dans la mémoire de
l ordinateur → fichiers binaires
• Les flots binaires sont de simples suites d octets
• Les flots de texte ont une structure légèrement plus
riche, puisqu ils sont censés être organisés comme des
suites de lignes. Chaque ligne est faite d un nombre
quelconque de caractères distincts de \n et se termine
par ce caractère.
2
 Flots
• Les flots sont représentés dans les programmes par des
variables de type FILE*.
• La commande fopen permet d ouvrir un fichier
FILE * fopen(char *nom, char *mode);
Ex
FILE *fic;
fic = fopen( fic1 , r );
if (fic == NULL) {
printf( impossible d ouvrir le fichier );
exit(0);
}

3
 Flots
• Différents modes
– r (read) lecture. Le fichier doit exister.
– r+ comme "r", mais les opérations d écriture sont permises
aussi
– w écriture. Création d un fichier. Le fichier peut exister ou non,
s il existe, son contenu est entièrement effacé.
– w+ comme w , mais les opérations de lecture sont permises
aussi.
– a (append) allongement d un fichier. Le fichier existe ou non.
S il existe, son contenu n est pas effacé. Le descripteur du flot
crée est positionné en écriture à la fin du fichier. Seules les
opérations d écriture sont permises
– a+ comme a , mais les opérations de lecture sont permises
aussi

4
 Flots
• Mode binaire : Ajouter la lettre « b » au mode
– rb
– rb+
– wb
– …
• Pour fermer le fichier, on utilise fclose
int fclose(FILE *flot)
• Pour connaître la fin du fichier, on utilise feof
int feof(FILE *flot)
• Il existe 3 flots de texte automatiquement ouverts par le
système qui sont connectés aux organes d e/s. Ces
fichiers sont déclarés dans <stdio.h>
FILE * stdin, *stdout, *stderr
stdin – unité standard d entrée → clavier
stdout – unité standard de sortie → écran
stderr – unité standard d affichage des erreurs → 5
écran
 Entrées-sorties formattées
• fprintf
Analogue à printf, permet d écrire des données dans un
fichier
int fprintf(FILE * flot, char *format);
printf(“ form “, e1,…en) Û fprintf(stdout, “ form “, e1, …en)
• fscanf
Analogue à scanf, permet de lire des données à partir d un
fichier
int fscanf(FILE * flot, char *format)

6
 Entrées-sorties formattées
Supposons qu’un fichier contient 3 nombres séparés par un espace :
32 15 27
int main()
{
FILE* fic;
int score[3];
fic = fopen("test.txt", "r");
if (fic != NULL) {
fscanf(fichier, "%d %d %d", &score[0], &score[1], &score[2]);
printf("Les valeurs sont : %d, %d et %d", score[0],
score[1], score[2]);
fclose(fic);
}
return 0;
} 7
 Impression et lecture de caractères
• Similaires aux fonctions getchar et putchar, les fonctions
fgetc et fputc permettent respectivement de lire et
d écrire un caractère dans un fichier.
• fgetc renvoie le caractère lu dans le fichier, renvoie EOF
si la fin du fichier est détectée
int fgetc(FILE * flot)
• fputc retourne l entier correspondant au caractère lu
int fputc(int car, FILE * flot)
• Il existe également deux versions optimisées des
fonctions fgetc et fputc qui sont implémentées par des
macros
int getc(FILE *flot)
int putc(int c, FILE *flot)
8
 Impression et lecture de caractères
• Le programme suivant lit le contenu du fichier texte « entree », et le
recopie caractère par caractère dans le fichier « sortie »
#include <stdio.h>
#include <stdlib.h>
#define ENTREE “entree.txt“
#define SORTIE “sortie.txt”
int main( ) {
FILE *f_in, *f_out;
int c;
if ( ( f_in = fopen(ENTREE, “r”) ) = = NULL) {
fprintf(stderr, “\n Erreur: Impossible de lire le fichier %s\n”, ENTREE);
exit(1); // ou bien return (EXIT_FAILURE);
}
if ( ( f_out = fopen(SORTIE, “w”) = = NULL) {
fprintf(stderr, “\n Erreur : Impossible d’écrire dans le fichier %s\n”,
SORTIE);
9
 Impression et lecture de caractères
return (EXIT_FAILURE);
}
while ( ( c = fgetc(f_in) ) ! = EOF)
fputc(c, f_out);
fclose(f_in);
fclose(f_out);
return( EXIT_SUCCESS);
}

10
 Entrées-sorties de lignes
• Une ligne est une séquence de caractères terminée par le caractère
\n
• Ecriture d une ligne
int fputs(const char*s, FILE *f);
la fonction fputs écrit dans le flot de sortie f la chaîne terminée par le
caractère nul et pointée par s.
fputs renvoie le dernier caractère écrit si succès, sinon EOF
• Lecture d une ligne
char* fgets(char *s, int n, FILE *f);
fgets lit des chaînes de caractères depuis le flot d entrée f et les place
dans la chaîne s.
la fonction cesse la lecture soit lorsque n-1 caractères ont été lus, soit
suite à la lecture d un caractère de saut de ligne (\n)
fgets renvoie la chaîne s si succès, sinon NULL
11
 Entrées-sorties de lignes
#include <stdio.h>
#include <stdlib.h>
#define TAILLE_MAX 500

int main()
{
FILE* fic;
char chaine[TAILLE_MAX] ;

fichier = fopen("test.txt", "r");

if (fic != NULL)
{
while (fgets(chaine, TAILLE_MAX, fic) )
12
{
 Entrées-sorties de lignes

printf("%s", chaine);
}

fclose(fic);
}

return 0;
}

Autre façon de lire une chaîne de caractères au clavier :

fgets(chaine, TAILLE_MAX, stdin);

13
 Entrées-sorties de lignes
• Lecture de fichier texte avec fgets + analyse avec sscanf
Supposons qu’on dispose d’1 fichier avec le format suivant :
un nom (sans espaces) suivie d’une date de naissance 2 janvier 1975
par exple 1ère ligne : Moussa_Fall 20 décembre 1989
typedef struct {
char nom[20];
short int jour;
char mois[10];
short int annee;
} PERSONNE;
void main(void) {
FILE* fic ;
char ligne[81]; PERSONNE pers;
fic = fopen("individus.dat", "r") ;
14
 Entrées-sorties de lignes
if (fic==NULL) {
puts("Pb d'ouverture du fichier essai.dat !"); exit(0);
}
/* Lecture du fichier par fgets+sscanf (la fin de fichier est atteinte quand
fgets renvoie NULL) : */
while ( fgets( ligne, 81, fic) != NULL ) {
if (sscanf(ligne,"%s%hd%s%hd", pers.nom, &pers.jour,
pers.mois, &pers.annee) == 4)
{ printf("\n nom: %s ", pers.nom ) ;
printf("\n date naiss: %2hd %s %hd\n",pers.jour, pers.mois,
pers.annee);
} else
puts("Pb de lecture avec sscanf (format de ligne incorrect?)") ;
}
fclose( fic ) ;
15
}
 Entrées-sorties binaires
• On utilise principalement les deux fonctions suivantes :
– size_t fread(void *dest, size_t taille, size_t nombre, FILE *flot)
Cette fonction essaye de lire sur le flot indiqué nombre objets,
chacun ayant la taille indiquée, et les copie les uns à la suite des
autres dans l espace pointé par dest. Elle renvoie le nombre
d objets effectivement lus, qui peut être inférieur au nombre
demandé, à cause de la rencontre de fin de fichier.
– size_t fwrite(void *source, size_t taille, size_t nombre, FILE
*flot)
Cette fonction écrit les nombre objets, chacun ayant la taille
indiquée, qui se trouvent les uns à la suite des autres à l adresse
indiquée par source. Elle renvoie le nombre d objets écrits, qui peut
être inférieur au nombre demandé
Exple 1

16
 Entrées-sorties binaires
#include <stdio.h>
main( ) {
int n;
char nom[20];
FILE * fic;
printf( Donner le nom du fichier " );
gets(nom);
fic = fopen(nom, “wb“);
if ( fic = = NULL) {
printf(“Impossible d’ouvrir le fichier”); exit(0);
}
do {
printf(“Donner un entier”);
scanf(“%d”, &n);
17
 Entrées-sorties binaires
if (n) fwrite(&n, sizeof(n), 1, fic);
} while (n);
fclose(fic);
}
Exple 2 : supposons qu on dispose de produits
typedef struct prod {
---
---
} PRODUIT;
FILE *fic; PRODUIT p;
fic = fopen(“essai“, “wb+”);
…
fread(&p, sizeof(p), 1, fic);
fwrite(&p, sizeof(p), 1, fic);
18
 Entrées-sorties binaires
• Exple 3 : Copie d un fichier
#include <stdio.h>
#define MAXTAMPON 512
int main(int argc, char *argv[])
{
FILE * srce, *dest;
char tampon[MAXTAMPON];
int nbre;
if (argc < 3 ) {
fprintf(stderr, “emploi : %s srce dest“, argv[0]); exit(1);
}
if ( ( srce = fopen(argv[1], “r”) ) = = NULL) {
fprintf(stderr, “impossible d’ouvrir %s “, argv[1]; exit(2);
}
19
 Entrées-sorties binaires
if ( ( dest = fopen(argv[2], “w”) ) = = NULL) {
fprintf(stderr, “impossible d’ouvrir %s “, argv[2]; exit(3);
}
while ( (nbre = fread(tampon, 1, MAXTAMPON, srce) ) > 0 )
fwrite(tampon, 1, nbre, dest);
fclose(dest);
fclose(srce);
}

20
Positionnement dans les fichiers
int fseek( FILE *flot, long deplacement, int origine)
Cette fonction positionne le pointeur de fichier associé au flot indiqué.
La première lecture ou écriture ultérieure se fera à partir de la
nouvelle position. Celle-ci est obtenue en ajoutant la valeur du
déplacement à une valeur de base qui peut être la position
courante, la fin ou le début du fichier. C est l argument origine qui
indique de quelle base il s agit; la valeur de cet argument doit être
l une des constantes suivantes
SEEK_SET base = début du fichier
SEEK_CUR base = position courante
SEEK_END base = fin du fichier

la fonction renvoie zéro en cas de succès, une valeur non nulle en

cas d erreur

21
Positionnement dans les fichiers
Exple : Modification du nième article
main( ) {
…
fic = fopen(nom, “rb+“);
…
fseek(fic, (n-1) * sizeof(p), SEEK_SET);
fread(&p, sizeof(p), 1, fic);
...
p.valeur += 1000;
fseek(fic, (n-1) * sizeof(p), SEEK_SET);
fwrite(&p, sizeof(p), 1, fic);
}

22
 Fonctions sur les fichiers
• ftell
indique à quelle position vous êtes dans le fichier

• fseek
positionne le curseur à un endroit précis

• rewind
remet le curseur au début du fichier équivalent à fseek début

23
 Fonctions sur les fichiers
#include <stdio.h>
#include <stdlib.h>
#define NB 50
#define F_SORTIE "sortie.txt"
int main(void) {
FILE *f_in, *f_out;
int *tab;
int i;
// Initialisation du tableau
tab = (int*)malloc(NB * sizeof(int));
for (i = 0 ; i < NB; i++)
tab[i] = i;
/* ecriture du tableau dans F_SORTIE */
if ((f_out = fopen(F_SORTIE, "w")) == NULL){
24
 Fonctions sur les fichiers
fprintf(stderr, "\nImpossible d’ecrire dans %s\n",F_SORTIE);
return(EXIT_FAILURE);
}
fwrite(tab, NB * sizeof(int), 1, f_out);
fclose(f_out);
/* lecture dans F_SORTIE */
if ((f_in = fopen(F_SORTIE, "r")) == NULL) {
fprintf(stderr, "\nImpossible de lire dans %s\n",F_SORTIE);
return(EXIT_FAILURE);
}
/* on se positionne a la fin du fichier */
fseek(f_in, 0, SEEK_END);
printf("\n position %ld", ftell(f_in));

25
 Fonctions sur les fichiers
/* deplacement de 10 int en arriere */
fseek(f_in, -10 * sizeof(int), SEEK_END);
printf("\n position %ld", ftell(f_in));
fread(&i, sizeof(i), 1, f_in);
printf("\t i = %d", i);
/* retour au debut du fichier */
rewind(f_in);
printf("\n position %ld", ftell(f_in));
fread(&i, sizeof(i), 1, f_in);
printf("\t i = %d", i);
/* deplacement de 5 int en avant */
fseek(f_in, 5 * sizeof(int), SEEK_CUR);
printf("\n position %ld", ftell(f_in));
fread(&i, sizeof(i), 1, f_in);
26
 Fonctions sur les fichiers
printf("\t i = %d\n", i);
fclose(f_in);
return(EXIT_SUCCESS);
}

A l’exécution :
position 200
position 160 i = 40
position 0 i=0
position 24 i=6

27