FICHIERS.

FICHIERS

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.

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éments qu'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.

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.

Les Fichiers Fichier direct 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.

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.

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.

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é.

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);

Ouverture d’un fichier - les valeurs permises pour mode: “r” (read) ouverture d'un fichier; le contenu n'est pas détruit “r+” comme "r", mais les opérations d'écriture sont permises “w” (write) création d'un fichier; s'il existe, son contenu est effacé “w+” comme "w", mais les opérations de lecture sont permises “a” (append) allongement d'un fichier; les opérations d'écriture sont permises; s'il existe, son contenu n'est pas effacé. “a+” comme "a", mais les opérations de lecture sont permises “rb”,”r+b” “wb”,”ab”, “w+b”, “a+b” si on envisage d'utiliser le fichier en mode binaire il faut ajouter la lettre b

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);

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 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. Renvoie le 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.

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;

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);

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> /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é.

Lecture et écriture textuelles Exemple Création du fichier. do /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);

Lecture et écriture textuelles Exemple p=fopen(f_nom,"r"); /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); } 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 ligne par ligne.

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 );

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>);

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>);

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> /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é.

Lecture et écriture textuelles Exemple Création du fichier. do { printf("\nnom:"); gets(nom); /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); } Lire et afficher le fichier. Entrer f_nom:b nom:detail1 prix:2.50 Enregistremen suivant?O/N: nom:detail2 prix:50 detail detail

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);

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). fwrite permet 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);

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> /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é.

Lecture et écriture en mode binaire Exemple Création du fichier. do /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.

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> /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.

Lecture et écriture en mode binaire Exemple for (i = 0 ; i < NB; i++) /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); Écrire dans le fichier 1 objet (le tableau).

Lecture et écriture en mode binaire Exemple fread(tab2, NB * sizeof(int), 1, f_in); /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).

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);

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);

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);

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+");

(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 fwrite( & article, sizeof(ARTICLE), 1, fichier); écriture de la composante de rang n

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> /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

Les Fichiers L'accès relatif aux éléments des fichiers Exemple
rewind(sortie); /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 22 33

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> /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

Les prototypes FILE *writefile(char *name_file); /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) ; }

FILE *writefile(char *name_file) /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

int readfile(FILE *fp,char *name_file) /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

Changer le champ groupe. Ouverture du fichier à être changer. FILE *updatefile(FILE *fp,char *name_file) /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) ; }

while(fread(&s,sizeof(s),1,fp)==1) /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); fclose(fp); return(fp); Changer le champ groupe.

Entrer le nom du fichier: a nom=>Ivanov groupe=>12 note =>4 Element suivant? Y/N => nom=>Petrov groupe=>13 note =>5 Le fichier est cree Ivanov Petrov Le fichier est affiche L'element lu: Ivanov On va changer le groupe? Y/N : Petrov Entrer le groupe :12 Petrov 12 5 Le changement du fichier. L’affichage du fichier. La création du fichier. L’affichage du fichier.

FICHIERS.

Présentations similaires

Présentation au sujet: "FICHIERS."— Transcription de la présentation:

Présentations similaires

Notre projet

Feed-back

Entrer

S'autoriser via un réseau social:

FICHIERS.

Présentations similaires

Présentation au sujet: "FICHIERS."— Transcription de la présentation:

Présentations similaires

Notre projet

Feed-back