Terminologie: dans ces notes flot signifie un objet du type
FILE *
(un pointeur vers FILE).
Ouverture et fermeture d'un flot
Ouverture d'un flot:
FILE *fopen(const char *chemin, const char *mode)
La fonction retourne le flot en cas de succès et NULL en cas d'échec.
Le paramètre chemin donne le chemin vers le fichier.
Le paramètre mode donne le mode d'ouverture et peut prendre une de 6 valeurs:
|
mode
|
accès
|
comportement |
| si le fichier existe |
si le fichier n'existe pas |
| r |
lecture |
|
erreur |
| w |
écriture |
troncature |
création |
| a |
écriture |
|
création |
| r+ |
lecture et écriture |
|
erreur |
| w+ |
troncature |
création |
| a+ |
|
création |
La significations de lettres r,w,a
est évidente :
-
r -- read
-
w -- write
-
a -- append
Dans le tableau ci-dessus
troncature signifie qu'à l'ouverture
la taille du fichier est ramenée à 0, c'est-à-dire le fichier existant
ouvert en mode d'écriture sera effacé.
Dans les modes a et a+
les écritures sont effectuées à la fin du flot.
Puisque fopen retourne NULL en cas d'échec,
l'ouverture correcte d'un fichier aura la forme
FILE *flot;
if( ( flot = fopen(nom_fichier,mode) ) == NULL ){
/* on traite ici l'échec de l'ouverture
* par exemple comme ci-dessous */
fprintf(stderr, "ouverture du fichier %s impossible", nom_fichier);
return EXIT_FAILURE;
}
On ferme le flot à l'aide de :
int fclose(FILE *flot)
Flots standards
Au début de l'exécution du programme il y a déjà trois flots ouverts:
-
stdin flot d'entrée standard,
-
stdout flot de sortie standard,
-
stderr flot d'erreur standard.
Entrées/sorties formatées
int fprintf(FILE *flot, const char *format, ...)
int printf(const char *format, ...)
int fscanf(FILE *flot, onst char *format,...)
int scanf(const char *format,...)
Quelques formats:
|
%s
|
char *
|
|
%c
|
char
|
|
%d et %i
|
int |
| %hd et %hi | short |
| %ld et %li | long |
| %e et %f | double |
| %u | unsigned int |
Lecture et écriture de lignes
La fonction
char *fgets(char *tampon, int taille, FILE *flot)
lit une ligne (jusqu'à le caractère de la nouvelle ligne '\n' inclus) dans un tampon.
fgets lit au plus taille-1 caractères et place à la fin de la chaîne lue le
caractère '\0'.
int fputs(const chat *chaine, FILE *flot)
int puts(const char* chaine)
La fonction fputs écrit une ligne (c'est-à-dire
tous les caractères jusqu'à le caractère de la nouvelle ligne '\n')
dans un flot. puts effectue la même opération sur le flot stdout.
Lecture/écriture d'un caractère
La lecture d'un caractère s'effectue avec:
int fgets(FILE *flot)
int getc(FILE *flot)
int getchar(void)
getc c'est la même chose que fgets mais implémenté avec une macro-fonction.
getchar lit sur le flot stdin.
Ces fonctions retournent EOF en cas d'échec.
L'écriture d'un caractère dans flot :
int fputc(int caractere, FILE *flot)
int putc(int caractere, FILE *flot)
int putchar(int caractere)
Ces fonctions retournent le caractère écrit en cas de succès et EOF
en cas d'erreur.
La fonction
int ungetc(int caractere, FILE *flot)
remet un caractère dans un flot.
Entrées/sorties binaires
size_t fread(void *tampon, size_t taille, size_t nombre, FILE *flot)
size_t fwrite(void *tampon, size_t taille, size_t nombre, FILE *flot)
tampon donne l'adresse du début d'un tampon utilisé pour la lecture/écriture,
nombre donne le nombre d'éléments à lire/écrire et taille la taille d'un élément.
Par exemple si:
struct donnee{
int coeff;
double val:
};
typedef struct donnee donnee;
donnee tab[100]; /*tableau de structures*/
FILE *flot;
int i;
alors
fwrite(tab, sizeof( donnee ), 50, flot);
permettra d'écrire 50 premiers éléments du tableau
tab dans le flot.
On pourra lire ces éléments avec
fread(tab, sizeof( donnee ), 50, flot);
Les fonctions fread et fwrite
le nombre d'éléments lus/écrits.