· L'accès séquentiel : il consiste à traiter les informations "séquentiellement" c'est à dire dans l'ordre dans lequel elles apparaissent dans le fichier.
· L'accès direct : il consiste à se placer immédiatement sur l'information souhaitée sans avoir à parcourir celles qui précèdent.
Les fonctions de base pour l'ouverture et la fermeture des fichiers
La structure FILE
· FILE : est une structure prédéfinie dans la librairie stdio.h. Elle permet à un programme de manipuler les fichiers en stockant toutes les informations utiles se rapportant à ces derniers et notamment celles qui se rapportent aux tampons associés à ces derniers (adresse de début, taille en octets,…).
Ouverture d'un fichier : (fopen)
Prototype :
FILE* fopen(char* NomFich, char* ModeOuverture)
Paramètres :
· Le nom du fichier concerné fourni sous forme d'une chaîne de caractères. · Une chaîne indiquant le mode d'ouverture. Les modes possibles sont :
r Lecture seulement (le fichier doit exister). Retourne NULL si le fichier n'existe pas
w Écriture seulement. Si le fichier n'existe pas, il est créé. S'il existe son ancien contenu est perdu.
a Écriture en fin de fichier (appendding). Si le fichier existe déjà, il sera étendu, s'il n'existe pas, il sera créé (cas du w). r+ Lecture et écriture. Le fichier doit exister. Le contenue n'est pas perdu.
w+ Création pour lecture et écriture. Si le fichier existe, son contenu sera détruit.
a+ Lecture ou extension : si le fichier n'existe pas, il sera créé, s'il existe le pointeur sera positionné en fin de fichier. L’écriture se fait en fin de fichier.
Fermeture d'un fichier (fclose)
Prototype :
int fclose( FILE *F );
Paramètres :
F le fichier à fermer.
Valeur de retour :
0 si le fichier a été convenablement fermé. Autre fonction de fermeture de fichier int _fcloseall( void )
Vidage des tampons (fflush)
Prototype :
int fflush(FILE *stream ); <stdio.h>
Paramètres :
F: le tampon à vider.
Valeur de retour :
0 si succès et EOF si erreur.
Autre fonction :
int flushall(void); <stdio.h> Vide tous les tampons associés aux fichiers ouverts.
Les fonctions de lecture et d'écriture binaires dans les fichiers
Écriture dans un fichier (fwrite)
Prototype :
size_t fwrite(const void* ptr,size_t sizeU, size_t count, File* F)
Paramètres :
· ptr : Adresse de début du bloc d'informations à écrire dans le fichier.
· SizeU : taille en octets du bloc unitaire de données à écrire. Généralement, c'est la taille du type des données. · count : nombre de blocs unitaires de données à écrire.
· F : pointeur sur le fichier dans lequel l'écriture sera faite.
Rôle :
fwrite permet de transférer un bloc de données de taille (count x sizeU) octets, situé en mémoire à l'adresse ptr dans le fichier pointé par F.
Valeur de retour :
Nombre d'unités de données (les SizeU) réellement écrites dans le fichier. Lecture à partir d'un fichier (fread)
Prototype :
size_t fread(void* ptr, size_t sizeU, size_t count, File* F);
Paramètres :
· ptr : Adresse de début du bloc de mémoire dans lequel seront stockées les informations lues à partir du fichier. · SizeU : taille en octets du bloc unitaire de données à lire.
· count : nombre de blocs unitaires de données à lire.
· F : pointeur sur le fichier à partir duquel les informations sont lues.
Rôle :
fread lit (count x sizeU) octets d'informations à partir du fichier F et les place dans le bloc mémoire pointé par ptr.
Valeur de retour :
Détection de la fin d'un fichier (feof)
Prototype :
int feof(FILE* F);
Paramètre :
Fichier dont on veut détecter la fin.
Valeur de retour :
Vrai si la fin du fichier a été atteinte et faux sinon.
Remarque :
Il est à noter qu'il n'est pas suffisent d'avoir lu le dernier octet du fichier pour retourner vrai mais il faut lire au delà du dernier octet.
Exemple 1:
Le programme suivant enregistre d'une manière séquentielle une suite d'entiers dans un fichier.
#include <stdio.h> void main() { char NomFichier[21]; int n; FILE* Fichier;
printf("Donnez le nom du fichier à créer : "); scanf("%20s", NomFichier); Fichier=fopen(NomFichier,"w"); do { printf("Donnez un entier : "); scanf("%d",&n); if(n) fwrite (&n,sizeof(int),1,Fichier); } while(n); fclose(Fichier); } Exemple 2 :
Le programme suivant fait un parcours séquentiel du fichier précédemment créé et liste son contenu.
#include <stdio.h> void main() { char NomFichier[21]; FILE* Fichier; int n;
printf("Donnez le nom de fichier à lire : "); scanf("%20s",NomFichier); Fichier=fopen(NomFichier,"r"); while(!feof(Fichier)) { if(fread(&n, sizeof(int),1,Fichier)) printf("\n%d",n); } fclose(Fichier); }
Accès direct aux fichiers
· Chaque fichier possède un pointeur interne qui indique la position courante à partir de laquelle se font les opérations de lecture et d'écriture. Au moment de l'ouverture du fichier, cette position se trouve tout au début de ce dernier sauf pour les modes a et a+ où elle se trouve en fin de fichier. Elle s'incrémente par la suite, après toute opération d'accès, du nombre d'octets lus ou écrits.
· La position courante se situe toujours au niveau de l'octet qui succède immédiatement le dernier bloc d'informations lu ou écrit.
Positionnement du pointeur interne des fichiers
En mode d'accès direct. Il est possible d'agir sur la position courante d'un fichier de façon à la placer directement à un endroit précis sans avoir besoin de faire un déplacement séquentiel. Cette action se fait à l'aide de la fonction fseek.
Prototype :
int fseek(FILE* F, int offset, int origine);
Paramètres :
· F : Le fichier concerné par le déplacement.
· Offset : la valeur avec laquelle est déplacé le pointeur du fichier.
· Origine : donne l'origine à partir de laquelle est fait le déplacement. Trois origines sont distinguées. Elles sont définies par les constantes symboliques suivantes :
· SEEK_SET ou (0) : offset désigne dans ce cas un déplacement en octets par rapport au début du fichier. · SEEK_CUR ou (1) : Offset désigne un déplacement par rapport à la position courante. Offset peut être dans
ce cas une valeur positive ou négative.
· SEEK_END ou (2) : Offset désigne un déplacement par rapport à la fin du fichier.
Valeur de retour
· 0 si le positionnement s'est bien déroulé. · Une valeur non nulle sinon.
· Une valeur quelconque pour une tentative de positionnement en dehors du fichier.
Exemple : #include <stdio.h> void main() { char NomFichier[21]; int n; long rang; FILE * Fichier;
printf("donnez le nom du fichier à consulter : "); scanf("%s",NomFichier);
printf("Donnez le rang de l'entier à consulter : "); scanf("%ld",&rang);
Fichier = fopen(NomFichier, "r");
fseek(Fichier, sizeof(int)*(rang-1),SEEK_SET); fread(&n,sizeof(int),1,Fichier);
printf("la valeur est : %d",n); fclose(Fichier);
}
Détermination de la position courante d'un pointeur de fichier (ftell)
Prototype :
long ftell( FILE * F);
Valeur de retour :