TP7 : Fichiers Programmation en C (LC4) Semaine du 10 mars 2007 1 Fichiers : les bases Afin de pouvoir stocker des données, ou d exploiter des données déjà existantes, il est indispensable de pouvoir manipuler des fichiers. C est ce que nous allons voir dans ce TP. 1.1 La syntaxe : ouverture et fermeture Pour toutes les opérations sur les fichiers, il faut inclure le header stdio.h (c est à dire mettre un #include<stdio.h> au début du programme). Un fichier s identifie par son nom. À partir du nom d un fichier, on peut ouvrir un «canal» permettant de lire ou écrire dans ce fichier. Le type de ces canaux est nommé FILE. Il s agit d un type «abstrait», dont la définition dépend fortement du système. On ne doit donc pas chercher à regarder à l intérieur, mais simplement appeler dessus les fonctions standards décrites ci-dessous. Ces fonctions travaillent en fait toutes avec des FILE *. Pour ouvrir un canal vers un fichier, on utilise la fonction FILE * fopen(char * nom_de_fichier, char * mode). Le mode sert à spécifier quelle sorte de canal l on veut. On utilisera le mode «écriture», dénommé par la chaine "w" et le mode «lecture», dénommé par la chaine "r". Ainsi les lignes : FILE f 1 ; f 1 = fopen ( blop, r ) ; ouvrent le fichier blop en lecture. Le fichier doit exister si on cherche à le lire, par contre, si on l ouvre en mode écriture et qu il n existe pas, il sera créé automatiquement. Si il existe déjà, il sera tronqué. Si l ouverture échoue, fopen renvoie NULL. Si elle réussie, fopen renvoie un pointeur vers un canal, et l on peut par la suite passer ce pointeur en argument aux diverses fonctions travaillant sur des FILE *. Pour fermer un canal après l avoir utilisé, on utilise FILE * fclose(file * fichier). Il ne faut pas faire de free, car fclose fait déjà ce qu il faut. Il est indispensable de fermer un canal après utilisation, pour au moins deux raisons : Les écritures dans un canal ne sont pas immédiates, elles sont regroupées en gros blocs, pour des raisons d efficacité, donc il reste souvent des données en attente d écriture, et la fermeture du canal déclenche l écriture de ces données Il y a souvent des limites au nombre de canaux qu un programme peut avoir ouvert simultanément. Si la fermeture réussie, fclose renvoie 0, autrement il renvoie la valeur EOF (une macro définie par stdio.h, qui a de multiples usages). On se retrouve avec le code suivant : // debut de l a manipulation du f i c h i e r FILE f 1 ; i f ( ( f 1 = fopen ( blop, r ))==NULL){ p r i n t f ( %s, e r r e u r l o r s de l ouverture de blop \n ) ; e x i t ( 1 ) ;
// u t i l i s a t i o n du f i c h i e r... // f i n de l a manipulation du f i c h i e r i f ( f c l o s e ( f 1)==EOF){ p r i n t f ( %s, e r r e u r l o r s de l a fermeture de blop \n ) ; e x i t ( 1 ) ; 1.2 Lecture par caractère La fonction pour lire un caractère depuis un canal fich est int fgetc(file * fich). Elle renvoie un entier, qui est soit un caractère, soit la valeur EOF si on se trouve à la fin du fichier. Lorsqu on ouvre un fichier, le programme a un «curseur» situé au début du fichier. Les premiers caractères lus seront les premiers caractères du fichiers. À chaque caractère lu, le curseur se décale d un caractère vers la fin du fichier. Exercice 1 Créez avec votre éditeur un fichier exo1.txt où figurera uniquement votre prénom puis votre nom séparés d un espace. Écrivez une fonction void prenom(file * f) qui lit le prenom sur le canal f censé pointer vers exo1.txt, et l affiche à l écran. Lancez la deux fois de suite dans le main. Que se passe-t il? Exercice 2 void lit prenom (FILE f ){ while ( ( ( c=f g e t c ( f ))!= ) && ( c!=eof) ) p r i n t f ( %c, c ) ; Exercice 3 Écrivez une fonction compte_c(file * f) qui renvoie le nombre de caractères d un fichier. Écrivez une fonction compte_m(file * F) qui renvoie le nombre de mots d un fichier. Les mots sont séparés par des espaces ou des retours à la ligne. Écrivez une fonction compte_l qui renvoie le nombre de lignes. Exercice 4 int compte c (FILE f ){ int cpt =0; while ( f g e t c ( f )!=EOF) return cpt ; cpt++; int compte m (FILE f ){ int cpt =0; int on est sur un mot =0; while ( ( c=f g e t c ( f ))!=EOF) i f ( c== c== \n ) on est sur un mot =0; else { i f (! on est sur un mot ) { on est sur un mot =1; cpt++;
return cpt ; int compte l (FILE f ){ int cpt =0; while ( ( c=f g e t c ( f ))!=EOF) i f ( c== \n ) cpt++; return cpt ; Exercice 5 Faites un programme qui prend en argument sur la ligne de commande le nom d un fichier, et une lettre (c,m ou l) et qui renvoie selon cette lettre soit le nombre de caractères, de mots ou de lignes du fichier. Exercice 6 int main ( int argc, char argv ){ FILE f ; i f ( argc! = 3! argv [ 2 ] [ 0 ] argv [ 2 ] [ 1 ] ( argv [ 2 ] [ 0 ]! = c &&argv [ 2 ] [ 0 ]! = m &&argv [ 2 ] [ 0 ]! = l ) ) { p r i n t f ( %s \n, mauvaise syntaxe ) ; e x i t ( 1 ) ; f=fopen ( argv [ 1 ], r ) ; i f (! f ) { p r i n t f ( %s \n, f i c h i e r i n e x i s t a n t ) ; switch ( argv [ 2 ] [ 0 ] ) { case c : p r i n t f ( nombre de l e t t r e s : %d\n, compte c ( f ) ) ; break ; case m : p r i n t f ( nombre de mots : %d\n, compte m ( f ) ) ; break ; case l : p r i n t f ( nombre de l i g n e s : %d\n, compte l ( f ) ) ; break ; f c l o s e ( f ) ; e x i t ( 0 ) ; 1.3 Écriture par caractère La fonction int fputc(char m, FILE * f) écrit dans le canal f le caractère m. Exercice 7 Écrivez un programme qui réécrit son code dans un autre fichier. Par exemple si ce programme s appelle exo_n.c, alors il crée un fichier copie_exo_n.c qui est une copie de lui-même. Exercice 8
#include <s t d i o. h> void c o p i e (FILE fs, FILE fd ){ while ( ( c=f g e t c ( f s ) )!= EOF) f putc ( c, fd ) ; int main ( int argc, char argv ){ FILE s ource = fopen ( c o p i e. c, r ) ; FILE dst = fopen ( c o p i e, w ) ; c o p i e ( source, dst ) ; f c l o s e ( s ource ) ; f c l o s e ( dst ) ; 1.4 Lecture et écriture Plusieurs fonctions permettent de lire et écrire dans des fichiers. Il existe entre autres fread et fwrite qui s emploient comme suit : fread : int fread(void * tableau, size_t taille, size_t n, FILE *f). Cette fonction tente de lire, dans le fichier f, n blocs de taille octets, et les écrit à l adresse tableau, qui doit donc pointer vers un tableau suffisamment grand que l on aura créé au préalable. Elle renvoie le nombre de blocs lus, qui peut être plus petit que n, par exemple si l on a atteint la fin du fichier, et elle renvoie 0 en cas d erreur. fwrite : int fwrite(void *tableau, int taille, int n, FILE *f) agit de manière similaire : elle écrit, dans le fichier f un nombre n de blocs de taille taille octets qu elle lit dans le tableau pointé par tableau. Elle renvoie le nombre de blocs écrits en résultat. Si il est inférieur à n, c est qu il y a eu une erreur. Exercice 9 À l aide de ces deux fonction écrire les fonctions mon_getc et mon_putc qui agissent comme les fonctions vues précédemment. Exercice 10 int mon getc (FILE f ){ char c ; i f ( f r e a d (&c, 1, 1, f )==0) return EOF; else return c ; int mon putc ( char c, FILE f ){ i f ( f w r i t e (&c, 1, 1, f )<1) return EOF; else return c ; Exercice 11 Écrivez un programme qui crée un formulaire : il prend en argument sur la ligne de commande un nom de fichier et des mots et crée un fichier avec un mot par ligne. Exercice 12 void c ree form ( int n, FILE f, char mots ){ int i ; for ( i =0; i <n ; i ++){ f w r i t e ( mots [ i ], 1, s t r l e n ( mots [ i ] ), f ) ; f w r i t e ( \n, 1, 1, f ) ;
int main ( int argc, char argv ){ FILE f 1=fopen ( argv [ 1 ], w ) ; cree form ( argc 2, f1, argv +2); f c l o s e ( f 1 ) ; 2 Entrée standard, sortie standard Quand un programme est lancé, il dispose de trois canaux d entrée sortie nommés stdin, stdout, et stderr. Ils peuvent être branchés sur des fichiers, mais c est rarement le cas. En temps normal, le canal stdin permet au programme de lire ce que l utilisateur tape sur le clavier, tandis que stdout et stderr sont affichés à l écran (la différence entre ces deux canaux est de nature purement conventionnelle : on est censé utiliser stdout pour des messages normaux, et stderr pour des messages d erreur, pour permettre à l utilisateur de trier entre les deux). Exercice 13 Implémenter une fonction affiche_ecran(char *s) qui affiche le contenu de s à l écran. Exercice 14 void a f f i c h e e c r a n ( char s ){ while ( s!= \0 ){ f putc ( s, stdout ) ; s++; Exercice 15 Implémenter un programme qui demande à l utilisateur de remplir un formulaire (par exemple nom, prénom, age, filière, adresse) et qui crée un fichier approprié avec toutes les données nécessaires. Exercice 16 char q u e s t i o n s []={ Nom, Prenom, age, f i l i e r e, Adresse, NULL ; void r e m p l i t (FILE out ) { char q u e s t i o n ; for ( q u e s t i o n=q u e s t i o n s ; q u e s t i o n ; q u e s t i o n++) { p r i n t f ( %s?, q u e s t i o n ) ; // f p r i n t f f o n c t i o n n e comme p r i n t f, avec un premier argument en p l u s // pour s p e c i f i e r sur q u e l canal e c r i r e. f p r i n t f ( out, %s :, q u e s t i o n ) ; while ( ( c=f g e t c ( s t d i n ))!= \n &&c!=eof) fputc ( c, out ) ; fputc ( \n, out ) ; fputc ( \n, stdout ) ; int main ( int argc, char argv ) { FILE out ; i f ( argc!=2) { f p r i n t f ( s t d e r r, %s \n, I l f a u t p a s s e r exactement un argument. ) ;
e x i t ( 1 ) ; out=fopen ( argv [ 1 ], w ) ; i f ( out==null) { p e r r o r ( Echec l o r s de l ouverture du f i c h i e r ) ; e x i t ( 2 ) ; r e m p l i t ( out ) ; i f ( f c l o s e ( out ) ) e x i t ( 3 ) ; else e x i t ( 0 ) ;