FICHIERS

1. FICHIERS

2. Les Fichiers • Les "entrées-sorties conversationnelles '‘ échangent des informations entre le programme et l'utilisateur. • Le terme de fichier désigne un ensemble d'informations situé sur une ''mémoire de masse'' telle que le disque ou la disquette. • Un fichier (angl.: file)est un ensemble structuré de données stocké en général sur un support externe. • Tous les périphériques, qu ' ils soient d'archivage (disque, disquette , . . . ) ou de communication (clavier, écran, imprimante,...), peuvent être considérés comme des fichiers. • Le principal inconvénient est le temps d'accès à une donnée.

3. Les Fichiers • Un fichier structuré contient une suite d'enregistrements homogènes, qui regroupent le plus souvent plusieurs composantes appartenant ensemble (champs). • L'insertion et la suppression d'élémentsqu'en fin d'un fichier devra passer par la création d'un nouveau fichier. • On distingue traditionnellement deux techniques de gestion de fichiers : • l'accès séquentiel consiste à traiter les informations "séquentiellement", c'est-à-dire dans l'ordre où elles apparaissent (ou apparaîtront) dans le fichier, • l'accès direct consiste à se placer immédiatement sur l'information souhaitée, sans avoir à parcourir celles qui la précèdent.

4. Les Fichiers Fichier séquentiel • Les enregistrements sont mémorisés consécutivement dans l'ordre de leur entrée et peuvent seulement être lus dans cet ordre. • Si on a besoin d'un enregistrement précis dans un fichier séquentiel, il faut lire tous les enregistrements qui le précèdent, en commençant par le premier.

5. Les Fichiers Fichier séquentiel • Le grand avantage est qu'il peut contenir des données de tout type, de taille différente. • Il ne peut en général pas être modifié, la seule possibilité étant l'ajout derrière les données déjà stockées. Fichier direct • Il correspond à un tableau en mémoire : toutes ses composantes ont la même taille, on peut donc accéder directement à la Nième. • Les insertions et suppressions nécessitent des décalages des composantes suivantes.

6. Les Fichiers La mémoire tampon • Les accès à un fichier se font par l'intermédiaire d'une mémoire tampon (angl.: buffer) -une zone de la mémoire centrale de la machine réservée à un ou plusieurs enregistrements du fichier. • L'utilisation de la mémoire tampon a l'effet de réduire le nombre d'accès à la périphérie d'une part et le nombre des mouvements de la tête de lecture/écriture d'autre part.

7. Les Fichiers Flots • Les fichiers sont vus par le programmeur comme des flots, c'est-à-dire des suites d'octets qui représentent des données selon une des deux modalités suivantes: • Soit le fichier contient les caractères (presque toujours le code ASCII). De tels fichiers sont appelés fichiers de texte. • Ils peuvent être affichés, édités, imprimés, etc.

8. Les Fichiers Flots • Soit le fichier contient des données enregistrées sous une forme qui est la copie exacte de leur codage dans la mémoire. On l'appelle alors fichier binaire. • Les opérations de lecture ou d'écriture sur de tels fichiers sont très rapides, car elles ne requièrent pas un travail d'analyse ou de synthèse de l'expression écrite des données. • Ils ne sont pas éditables ou imprimables. • Ils ne sont pas censés être transportables d'un logiciel à un autre, encore moins d'un système à un autre. • Ils sont utiles pour manipuler des données de grande taille ou ayant un type composé.

9. Les Fichiers Fonctions générales sur les flots • Les flots sont représentés dans les programmes par des variables de type FILE * (la structure FILE est définie dans le fichier <stdio.h>). • Ouverture d’un fichier - la fonction ouvre le fichier dont le nom est indiqué par la chaîne nom et rend un pointeur sur le flot correspondant, ou NULL si l'opération a échoué. FILE *fichier; Déclaration d’une fichier par la variable fichier FILE *fopen(const char *nom, const char *mode);

10. Les Fichiers Fonctions générales sur les flots • Ouverture d’un fichier - les valeurs permises pour mode:

11. Les Fichiers Fonctions générales sur les flots • Fermeture d’un fichier – la fonction ferme le flot indiqué, produisant l'écriture physique des tampons.Elle rend zéro en cas de succès, une autre valeur en cas d'erreur. • Fin de fichier (feof) - la fonction renvoie une valeur non nulle si et seulement si l'indicateur de fin de fichier du flot indiqué est vrai. feof n'est jamais vrai après l'ouverture (en lecture) du fichier, même lorsque ce dernier est vide. Il faut au moins une [tentative de] lecture pour le rendre vrai. int fclose(FILE *fichier); int feof(FILE *fichier);

12. Les Fichiers Fonctions générales sur les flots le schèma de lecture séquentielle d'un fichier FILE *pf; . . . pf = fopen(nom, "rb"); vérification du succès de l'ouverture de fichier . . . lecture de données sur fichier while ( ! feof(pf)) { traitement des données lues lecture de données sur fichier } . . .

13. Les Fichiers Fonctions générales sur les flots • Lecture et écriture textuelles • Lecture et écriture de caractères et de chaînes • Les fonctions de lecture - écriture effectuent la lecture ou l'écriture d'un caractère. Renvoiele caractère suivant sur le flot indiquè ou EOF si la fin du fichier est atteinte ou en cas d’erreur. int fgetc(FILE *flot); int fputc(int caractere, FILE *flot); Ecrit le caractere indiqué sur le flot. Renvoie le caractère écrit ou EOF en cas d’erreur.

14. Les Fichiers Fonctions générales sur les flots • Lecture et écriture textuelles • Exemple – Faire un programme qui lit et affiche le fichier "C:\AUTOEXEC.BAT" en le parcourant caractère par caractère. #include <stdio.h> #include <stdlib.h> main() { FILE *fp; fp = fopen("C:\\AUTOEXEC.BAT", "r"); if (!fp) { printf("Impossible d'ouvrir le fichier\n"); exit(-1); } while (!feof(fp)) putchar(fgetc(fp)); fclose(fp); return 0; }

15. Les Fichiers Fonctions générales sur les flots • Lecture et écriture textuelles • Lecture et écriture de caractères et de chaînes • La fonction de la lecture d'une ligne. On s'arrête lorsqu'elle a lu n-1 caractères ou lorsqu'elle a rencontré un caractère ‘\n‘. • La fonction d'écriture d'une ligne renvoie EOF en cas d'erreur, une valeur >= 0 dans les autres cas. lit des caractères sur le flot indiqué et les place dans l'espace pointé par s. char *fgets(char *s, int n, FILE *flot); écrit la chaîne s sur le flot indiqué. int fputs(const char *s, FILE *flot);

16. Les Fichiers Fonctions générales sur les flots • Lecture et écriture textuelles • Exemple – Faire un programme de: 1) création d’un fichier en entrant ligne par ligne son contenu par clavier; 2) d’affichage le fichier lu par lignes. #include <stdio.h> 1/3 #include <stdlib.h> #include <conio.h> #include <ctype.h> void main() { FILE *p; char f_nom[10],ligne[63]; printf("Entrer f_nom:"); gets(f_nom); p=fopen(f_nom,"w"); if(p==NULL) { printf("Le fichier n'est pas ouvert\n"); exit(1); } Ouverture du fichier avec un nom donné.

17. Les Fichiers Fonctions générales sur les flots • Lecture et écriture textuelles • Exemple Création du fichier. do 2/3 { printf("\nEntrer une ligne\n"); fgets(ligne,62,stdin); fputs(ligne,p); printf("Entrer caractere e(E) pour la fin"); } while(toupper(getch())!='E'); fclose(p);

18. Les Fichiers Fonctions générales sur les flots • Lecture et écriture textuelles • Exemple p=fopen(f_nom,"r"); 3/3 if(p==NULL) { printf("Le fichier n'est pas ouvert\n"); exit(1); } printf("\n"); fgets(ligne,62,p); while(!feof(p)) { puts(ligne); fgets(ligne,62,p); } fclose(p); } Lire et afficher le fichier. Entrer f_nom: a Entrer une ligne Traitement d’un fichier Entrer caractere e(E) pour la fin Entrer une ligne ligne par ligne. Entrer caractere e(E) pour la fin Traitement d’un fichier ligne par ligne.

19. Les Fichiers Fonctions générales sur les flots • Lecture et écriture textuelles • Lecture et écriture avec format Comme scanf mais sur le flot indiqué (à la place de stdin) int fscanf(FILE *flot, const char *format, ...&v1,…&vk ); Comme printf mais sur le flot indiqué (à la place de stdout) int fprintf(FILE *flot, const char *format, ... exp1,…expk );

20. Les Fichiers Fonctions générales sur les flots • Lecture et écriture textuelles • Lecture et écriture avec format • <FP> est un pointeur du type FILE* qui est relié au nom du fichier à lire. • <Adr1>, <Adr2>, ... , <AdrN> représentent les adresses des variables qui vont recevoir les valeurs des différentes rubriques d'un enregistrement lu dans le fichier. • <Form1>, <Form2>, ... , <FormN> représentent les spécificateurs de format pour la lecture des différentes rubriques. fscanf(<FP>,"<Form1>\n<Form2>\n...\n<FormN>\n", <Adr1>, <Adr2>, ... , <AdrN>);

21. Les Fichiers Fonctions générales sur les flots • Lecture et écriture textuelles • Lecture et écriture avec format • <FP> est un pointeur du type FILE* qui est relié au nom du fichier cible. • <Expr1>, <Expr2>, ... , <ExprN> représentent les rubriques qui forment un enregistrement et dont les valeurs respectives sont écrites dans le fichier. • <Form1>, <Form2>, ... , <FormN> représentent les spécificateurs de format pour l'écriture des différentes rubriques. fprintf(<FP>,"<Form1>\n<Form2>\n...\n<FormN>\n", <Expr1>, <Expr2>, ... , <ExprN>);

22. Les Fichiers Fonctions générales sur les flots • Lecture et écriture textuelles • Exemple – Faire un programme de: 1) création d’un fichier en entrant l’information d’enregistrements - détails (nom et prix); 2) d’affichage le fichier lu par enregistrements. #include <stdio.h> 1/2 #include <stdlib.h> #include<ctype.h> #include <conio.h> void main() { FILE *p; char f_nom[10], nom[20]; float prix; printf("Entrer f_nom:"); gets(f_nom); p=fopen(f_nom,"w"); if(p==NULL) { printf("Le fichier n'est pas ouvert\n"); exit(1); } Ouverture du fichier avec un nom donné.

23. Les Fichiers Fonctions générales sur les flots • Lecture et écriture textuelles • Exemple Création du fichier. do { printf("\nnom:"); gets(nom); 2/2 printf("prix:"); scanf("%f",&prix);fflush(stdin); fprintf(p,"%s\n%f",nom,prix); printf("Enregistremen suivant?O/N:"); } while(toupper(getch())=='O'); fclose(p); p=fopen(f_nom,"r"); if(p==NULL) { printf(" Le fichier n'est pas ouvert\n "); exit(1); } while(fscanf(p,"%s%f",nom,&prix)!=EOF) printf("\n%s %.2f",nom,prix); fclose(p); } Lire et afficher le fichier. Entrer f_nom:b nom:detail1 prix:2.50 Enregistremen suivant?O/N: nom:detail2 prix:50 Enregistremen suivant?O/N: detail1 2.50 detail2 50.00

24. Les Fichiers Fonctions générales sur les flots • Lecture et écriture en mode binaire • Lecture - la 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 destination. Elle renvoie le nombre d'objets effectivement lus (et non pas le nombre d'octets lus), qui peut être inférieur au nombre demandé, à cause de la rencontre de la fin du fichier, d'une erreur, etc. • Remarque: size_t, défini dans stddef.h, correspond au type du résultat de l'évaluation de sizeof. size_t fread(void *destination, size_t taille, size_t nombre, FILE *flot);

25. Les Fichiers Fonctions générales sur les flots • Lecture et écriture en mode binaire • Ecriture - la 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é (en cas d'erreur). • fwritepermet de transférer plusieurs blocs consécutifs de même taille à partir d'une adresse donnée. size_t fwrite(const void *source, size_t taille, size_t nombre, FILE *flot);

26. Les Fichiers Fonctions générales sur les flots • Lecture et écriture en mode binaire • Exemple - Faire un programme à: 1) enregistrer séquentiellement dans un fichier une suite de nombres entiers qu'on lui fournit au clavier; 2) lister le contenu du fichier crée. #include <stdio.h> #include <stdlib.h> 1/2 int main(void) { char nomfich[21] ; int n ; FILE * sortie,* entree ; printf ("nom du fichier a creer : ") ; scanf ("%20s", nomfich) ; sortie = fopen (nomfich, "wb") ; if(sortie == NULL) { printf("Le fichier n'est pas ouvert\n"); exit(1); } Ouverture du fichier avec un nom donné.

27. Les Fichiers Fonctions générales sur les flots • Lecture et écriture en mode binaire • Exemple Création du fichier. do 2/2 { printf ("donnez un entier : ") ; scanf ("%d", &n) ; if (n) fwrite(&n, sizeof(int), 1, sortie) ; } while (n) ; fclose (sortie) ; entree = fopen (nomfich, "rb") ; if(entree == NULL) { printf("Le fichier n'est pas ouvert\n"); exit(1); } while ( fread (&n, sizeof(int), 1, entree), ! feof(entree) ) { printf ("\n%d", n) ; } fclose (entree) ; return 0 ; } nom du fichier a creer: a donnez un entier : 22 donnez un entier : 33 donnez un entier : 44 donnez un entier : 0 22 33 44 Lire et afficher le fichier.

28. Les Fichiers Fonctions générales sur les flots • Lecture et écriture en mode binaire • Exemple - le programme suivant écrit un tableau d'entiers (contenant les 20 premiers entiers) avec fwrite dans le fichier sortie, puis lit ce fichier avec fread et imprime les éléments du tableau. #include <stdio.h> 1/3 #include <stdlib.h> #define NB 20 #define F_SORTIE "sortie" int main(void) { FILE *f_in, *f_out; int *tab1, *tab2; int i; tab1 = (int*)malloc(NB * sizeof(int)); tab2 = (int*)malloc(NB * sizeof(int)); Réservation de la mémoire dynamiques.

29. Les Fichiers Fonctions générales sur les flots • Lecture et écriture en mode binaire • Exemple for (i = 0 ; i < NB; i++) 2/3 tab1[i] = i; /* ecriture du tableau dans F_SORTIE */ if ((f_out = fopen(F_SORTIE, "wb")) == NULL) { fprintf(stderr, "\nImpossible d'ecrire dans le fichier %s\n",F_SORTIE); return(EXIT_FAILURE); } fwrite(tab1, NB * sizeof(int), 1, f_out); fclose(f_out); /* lecture dans F_SORTIE */ if ((f_in = fopen(F_SORTIE, "rb")) == NULL) { fprintf(stderr, "\nImpossible de lire dans le fichier %s\n",F_SORTIE); return(EXIT_FAILURE); } Écrire dans le fichier 1 objet (le tableau).

30. Les Fichiers Fonctions générales sur les flots • Lecture et écriture en mode binaire • Exemple fread(tab2, NB * sizeof(int), 1, f_in); 3/3 fclose(f_in); for (i = 0 ; i < NB; i++) printf("%d\t",tab2[i]); printf("\n"); return(EXIT_SUCCESS); } Lire du fichier 1 objet (le tableau). 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

31. Les Fichiers Fonctions générales sur les flots • Positionnement dans un fichier (ACCÈS DIRECT) • On peut se positionner а n'importe quel endroit précis du fichier à l 'aide de la fonction fseek. • La fonction positionne le pointeur du fichier associé au flot indiqué. • La première lecture ou écriture ultérieure se fera à partir de la nouvelle position (obtenue en ajoutant la valeur de déplacement à une valeur de base (origine) qui peut être la position courante, la fin ou le début du fichier. • La fonction renvoie zéro en cas de succès, une valeur non nulle en cas d'erreur. int fseek(FILE *flot, long deplacement, int origine);

32. Les Fichiers Fonctions générales sur les flots • Positionnement dans un fichier (ACCÈS DIRECT) • La valeur d’argument origine doit être une des constantes (définies dans <stdio.h>) : • La fonction à retourner la position courante dans le fichier (en nombre d'octets depuis l'origine) – ftell. SEEK SET : base = le début du fichier ou 0 SEEK CUR : base = la position courante ou 1 SEEK END : base = la fin du fichier ou 2 long ftell(FILE *flot);

33. Les Fichiers Fonctions générales sur les flots • Positionnement dans un fichier (ACCÈS DIRECT) • La fonction permettant de se positionner au début du fichier. – rewind équivalente аfseek(flot, 0, SEEK_SET); int rewind(FILE *flot);

34. Les Fichiers L'accès relatif aux éléments des fichiers (accès direct aux composantes (enregistrements) d'un fichier) • Le fichier puisse être vu comme une suite d'articles de même taille. • Cela s'obtient généralement en déclarant une structure qui représente un article, selon le modèle : typedef struct { . . . champs dont se composent tous les articles . . . } ARTICLE; . . . FILE *fichier; . . . fichier = fopen(nom , "rb+");

35. Les Fichiers L'accès relatif aux éléments des fichiers (accès direct aux composantes (enregistrements) d'un fichier) • Si les articles sont numérotés à partir de zéro: lecture de l'enregistrement de rang n ARTICLE article; . . . fseek(fichier, n * sizeof(ARTICLE), SEEK_SET); fread( & article, sizeof(ARTICLE), 1, fichier); . . . exploitation des valeurs des champs de article . . . affectation des champs de article . . . fseek(fichier, n * sizeof(ARTICLE), SEEK_SET); fwrite( & article, sizeof(ARTICLE), 1, fichier); . . . écriture de la composante de rang n

36. Les Fichiers L'accès relatif aux éléments des fichiers • Exemple – faire un programme de constituer un fichier d'entiers en laissant l'utilisateur les fournir dans l'ordre de son choix. #include <stdio.h> 1/2 int main(void) { char nomfich[21] ; FILE * sortie ; long num ; int n ; printf ("nom fichier : ") ; scanf ("%20s",nomfich) ; sortie = fopen (nomfich, "wb+") ; while (printf("\nrang de l'entier : "), scanf("%ld",&num), num) { printf ("valeur de l'entier : ") ; scanf ("%d", &n) ; fseek (sortie, sizeof(int)*(num-1), SEEK_SET); fwrite (&n, sizeof(int), 1, sortie) ; } écriture des composantes (n) dans le fichier selon leurs rang num

37. Les Fichiers L'accès relatif aux éléments des fichiers • Exemple rewind(sortie); 2/2 while(fread(&n,sizeof(int),1,sortie),!feof(sortie)) printf("%d\n",n); fclose(sortie) ; return 0 ; } Lire le fichier et afficher nom fichier : a rang de l'entier : 1 valeur de l'entier : 11 rang de l'entier : 3 valeur de l'entier : 22 rang de l'entier : 5 valeur de l'entier : 33 rang de l'entier : 0 11 0 22 0 33

38. Les Fichiers L'accès relatif aux éléments des fichiers • Exemple – Faire un programme C de création d'un fichier binaire d'éléments de type structuré. Chaque structure est composée des champs suivants: a) nom - chaîne de caractères; b) groupe - nombre entier; c) note - nombre reél. Afficher l’information des étudiants. Faire un changement du champ groupe si on decide de le faire. Utiliser les fonctions differentes pour chaque action. #include <stdio.h> 1/6 #include <conio.h> #include <ctype.h> #include <stdlib.h> struct student { char nom[60]; int groupe; float note; }; La définition du modèle

39. Les Fichiers L'accès relatif aux éléments des fichiers • Exemple Les prototypes FILE *writefile(char *name_file); 2/6 int readfile(FILE *fp,char *name_file); FILE *updatefile(FILE *fp,char *name_file); void main() { FILE *fp; int r; char name_file[30]; printf("Entrer le nom du fichier :") ; gets(name_file) ; fp=writefile(name_file) ; if(fp != NULL) printf("\nLe fichier est cree\n ") ; else { printf("Le fichier n'est pas cree") ; exit(1); } r=readfile(fp,name_file) ; if(r) printf(“\nLe fichier est affiche\n ") ; fp=updatefile(fp,name_file) ; readfile(fp,name_file) ; }

40. Les Fichiers L'accès relatif aux éléments des fichiers • Exemple FILE *writefile(char *name_file) 3/6 { FILE *fp; struct student s; if((fp=fopen(name_file,"wb")) == NULL) { printf("\nLe fichier %s n'est pas ouvert\n",name_file); exit(1) ; } do { printf("\nnom=>") ; gets(s.nom) ; printf("groupe=>") ; scanf("%d",&s.groupe) ; printf("note=>") ; scanf("%f",&s.note) ; while((getchar()) != '\n') ; fwrite(&s,sizeof(s),1,fp) ; printf("Element suivant? Y/N =>"); }while(toupper(getch())=='Y') ; fclose(fp) ; return(fp) ; } La création du fichier

41. Les Fichiers L'accès relatif aux éléments des fichiers • Exemple int readfile(FILE *fp,char *name_file) 4/6 { struct student temp; int flag=0; if((fp=fopen(name_file,"rb")) == NULL) { printf("\nLe fichier %s n'est pas ouvert\n",name_file); printf("\nPresser une touche") ; getch() ; exit(1) ; } while(fread(&temp,sizeof(temp),1,fp)==1) { flag=1; printf(“\n%s %d %.2f\n",temp.nom,temp.groupe,temp.note); } fclose(fp); if(!flag) printf("\nFichier vide. Creer le fichier !") ; return flag ; } Lire et afficher le fichier

42. Les Fichiers L'accès relatif aux éléments des fichiers • Exemple Changer le champ groupe. Ouverture du fichier àêtre changer. FILE *updatefile(FILE *fp,char *name_file) 5/6 { struct student s; long int pos; if((fp=fopen(name_file,"r+b")) == NULL) { printf("\nLe fichier %s n'est pas ouvert\n",name_file); exit(1) ; }

43. Les Fichiers L'accès relatif aux éléments des fichiers • Exemple while(fread(&s,sizeof(s),1,fp)==1) 6/6 { printf("\nL'element lu:\n"); printf("%s %d %.2f\n",s.nom,s.groupe,s.note); printf("On va changer le groupe? Y/N :") ; if(toupper(getch()) == 'Y') { printf("\nEntrer le groupe :") ; scanf("%d",&s.groupe) ; while((getchar()) != '\n') ; pos=ftell(fp)-sizeof(s) ; fseek(fp,pos,0); fwrite(&s,sizeof(s),1,fp); } pos=ftell(fp); fseek(fp,pos,0); } fclose(fp); return(fp); } Changer le champ groupe.

44. Les Fichiers L'accès relatif aux éléments des fichiers • Exemple Entrer le nom du fichier: a nom=>Ivanov groupe=>12 note =>4 Element suivant? Y/N => nom=>Petrov groupe=>13 note =>5 Element suivant? Y/N => Le fichier est cree Ivanov 12 4 Petrov 13 5 Le fichier est affiche L'element lu: Ivanov 12 4 On va changer le groupe? Y/N : L'element lu: Petrov 13 5 On va changer le groupe? Y/N : Entrer le groupe :12 Ivanov 12 4 Petrov 12 5 Le changement du fichier. L’affichage du fichier. La création du fichier. L’affichage du fichier.