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
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.
// 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.
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);
![[ESR] TP1 - Unix](https://imgv2-1-f.scribdassets.com/img/document/451686577/149x198/2ff2c4078f/1584210625?v=1)
