Introduction aux fichiers

1. Le type FILE*

Dans un programme C, un fichier est toujours une structure de type FILE définie dans la bibliothèque stdio.h et manipulée via son adresse par un pointeur FILE*. Pour utiliser un fichier dans un programme, ou une fonction du programme, la première chose à faire est de déclarer un FILE* :

#include <stdio.h> 
 
int main() 
{ 
FILE*f;  
    (...) 
    return 0; 
} 

2. Ouverture et fermeture d’un fichier

Dans la librairie standard stdio.h, la fonction :

FILE* fopen( const char* name ,const char* mode); 

permet d’ouvrir un fichier existant ou de créer un fichier. Cette fonction ouvre le fichier dont le nom comprenant le chemin d’accès est spécifié au premier paramètre et selon le mode donné par le second paramètre. Les deux sont des chaînes de caractères. Il y a six modes possibles : r, w, a, r+, w+, a+ et le caractère "b" ajouté ensuite permet de sélectionner une entrée/sortie en mode binaire.

Voici un tableau récapitulatif des différents modes possibles :

Pour refermer un fichier précédemment ouvert, la librairie stdio.h propose la fonction :

int fclose(FILE*); 

Cette fonction referme le fichier indiqué via le pointeur au paramètre p. Elle retourne EOF sur erreur et zéro sinon. EOF est une valeur sentinelle qui indique la fin du fichier.

Exemple d’ouverture/fermeture de fichier en mode binaire :

#define _CRT_SECURE_NO_WARNINGS // sous Visual Studio uniquement 
#include <stdio.h> 
 
int main() ...

1. Écriture et lecture en mode binaire

L’utilisation des fichiers binaires repose sur deux fonctions uniquement : une pour l’écriture et une pour la lecture. Ces deux fonctions sont dans la librairie standard stdio.h.

Pour écrire (save) des données :

size_t        fwrite ( const void*, size_t, size_t, FILE* ); 

Cette fonction écrit sur le fichier spécifié en p4, p3 objets de taille p2 en octet, rangés à partir de l’adresse p1. Elle retourne le nombre d’objets effectivement écrits.

Pour lire (load) les données d’un fichier :

size_t        fread ( void*, size_t, size_t, FILE*); 

Soit p1, p2, p3, p4, les paramètres spécifiés dans la fonction.

Cette fonction lit au plus p3 objets de taille p2 en octet sur le fichier spécifié en p4 et les copie à l’adresse p1. Elle retourne le nombre d’objets effectivement lus.

Exemple d’utilisation :

#include <stdio.h>  
#include <stdlib.h>  
 
#define NB_POINT    10  
 
typedef struct point { 
  int x, y; 
}t_point; 
 
void    init(t_point t[]); 
void    affiche(t_point t[]); 
 
int main() 
{ 
  FILE* f; 
  t_point...

1. Détecter la fin d’un fichier : EOF et feof()

En mode texte surtout, détecter la fin d’un fichier est souvent nécessaire. Il y a deux méthodes. La première du fait de la valeur EOF et la seconde avec la fonction feof().

Le caractère de fin de fichier EOF -------     <stdio.h> 

La fin des fichiers texte et binaire est marquée par une valeur définie par une macro constante EOF déclarée dans stdio.h. Cette valeur vaut en général -1 mais elle peut varier d’un environnement à l’autre. Dans les tests qui l’utilisent, il est plus sûr de toujours utiliser EOF plutôt que -1.

La plupart des fonctions du mode texte utilisent la valeur EOF pour signifier la fin du fichier. Cette valeur est aussi utilisée comme retour d’erreur, par exemple pour la fonction fclose().

int        feof ( FILE*) -------     <stdio.h> 

Cette fonction retourne vrai si la position courante dans le fichier passé en paramètre est à la fin et faux sinon. Cette fonction peut être utilisée pour les deux modes, texte et binaire.

2. Lecture/écriture de caractères

int fgetc ( FILE*) ------- <stdio.h> 

Cette fonction retourne un caractère lu sur le fichier spécifié en paramètre et EOF en cas d’erreur ou de détection de la fin du fichier. La macro int getc(FILE*) en est une autre forme équivalente.

int fputc (int, FILE*) ------- <stdio.h> 

Cette fonction écrit sur le fichier spécifié en p2 le caractère spécifié en p1. Elle retourne le caractère p1, sinon en cas d’erreur elle retourne EOF.

Exemple d’utilisation

Le programme ci-dessous ouvre en lecture seule le fichier entree.txt....

1. Sauvegarder et récupérer un tableau dynamique

Lors d’une sauvegarde de données obtenues dynamiquement, la taille peut être sauvegardée au début ou à la fin du fichier mais ce n’est pas obligatoire. En revanche, lors du chargement des données, il est nécessaire d’allouer la mémoire nécessaire des variables auxquelles sont affectées les données du fichier. Par exemple :

#include <stdio.h> 
#include <stdlib.h> 
#include <time.h> 
typedef struct point{ 
    int x,y; 
}t_point; 
 
void    init        (t_point**t,int nb); 
void    affiche     (t_point t[],int nb); 
 
int main() 
{ 
FILE*f; 
t_point*data; 
t_point*recup=NULL; 
int nb; 
 
    srand(time(NULL)); 
    if (fopen_s(&f,"test.bin", "wb+")==0){  
        // allocation et initialisation d'un tableau dynamique 
        // de taille aléatoire 
        nb=1+rand()%20; 
        init(&data,nb); ...