fwrite et fread sont des fonctions d'E/S qui opèrent par unités d'enregistrements. Les fonctions fread et fwrite sont généralement utilisées pour l'entrée et la sortie de fichiers binaires.
#include <stdio.h> size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream); size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream);
Valeur de retour : le nombre d'enregistrements lus ou écrits. En cas de succès, le nombre d'enregistrements retournés est égal à nmemb. En cas d'erreur ou à l'arrivée à la fin du fichier, le nombre d'enregistrements retournés est inférieur à nmemb, et il peut aussi renvoyer 0.
fread et fwrite sont utilisées pour lire et écrire des enregistrements. Un enregistrement désigne ici une séquence d'octets de longueur fixe, comme un int, une struct ou un tableau de longueur fixe. Le paramètre size spécifie la longueur d'un enregistrement, tandis que nmemb spécifie combien d'enregistrements lire ou écrire. Ces enregistrements sont stockés de manière contiguë dans l'espace mémoire pointé par ptr, occupant au total size * nmemb octets. fread lit size * nmemb octets depuis le flux de fichier et les enregistre dans ptr, tandis que fwrite écrit les size * nmemb octets de ptr dans le flux de fichier.
nmemb est le nombre d'enregistrements demandés en lecture ou en écriture. Le nombre d'enregistrements renvoyés par fread et fwrite peut être inférieur au nombre d'enregistrements spécifié par nmemb. Par exemple, si la position courante de lecture/écriture ne se trouve qu'à une longueur d'enregistrement de la fin du fichier, et que nmemb est spécifié à 2 lors de l'appel à fread, la valeur de retour sera 1. Si la position courante de lecture/écriture est déjà à la fin du fichier, ou si une erreur se produit pendant la lecture du fichier, fread renvoie 0. Si une erreur se produit pendant l'écriture du fichier, la valeur de retour de fwrite est inférieure à la valeur spécifiée par nmemb. L'exemple suivant se compose de deux programmes : un programme enregistre une struct dans un fichier, et l'autre programme lit la struct depuis le fichier.
#include <stdio.h> size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream); size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream);
Code de référence fwrite et fread :
code du fichier writerec.c
/* －－－－－－－－－－－－－－－－－－－writerec.c－－－－－－－－－－－－－－－ */
#include <stdio.h>
#include <stdlib.h>
struct record {
char name[10];
int age;
};
int main(void)
{
struct record array[2] = {{"Ken", 24}, {"Knuth", 28}};
FILE *fp = fopen("d:/test.txt", "w");
if (fp == NULL) {
perror("Open file recfile");
exit(1);
}
fwrite(array, sizeof(struct record), 2, fp);
fclose(fp);
return 0;
}
code du fichier readrec.c :
/* －－－－－－－－－－－－－－－－－－－readrec.c－－－－－－－－－－－－－－－－－ */
#include <stdio.h>
#include <stdlib.h>
struct record {
char name[10];
int age;
};
int main(void)
{
struct record array[2];
FILE *fp = fopen("d:/test.txt", "r");
if (fp == NULL) {
perror("Open file recfile");
exit(1);
}
fread(array, sizeof(struct record), 2, fp);
printf("Name1: %s\tAge1: %d\n", array[0].name, array[0].age);
printf("Name2: %s\tAge2: %d\n", array[1].name, array[1].age);
fclose(fp);
return 0;
}
$ gcc writerec.c -o writerec $ gcc readrec.c -o readrec
Il a été constaté que le fichier généré recfile ne peut pas être ouvert directement.
Raison :Nous traitons unestruct record struct comme un enregistrement. Parce que la structure contient des octets de remplissage, chaque enregistrement occupe 16 octets, et l'écriture de deux enregistrements dans le fichier occupe un total de 32 octets. Le fichier recfile généré par ce programme est un fichier binaire plutôt qu'un fichier texte, car il stocke non seulement des données de caractères mais aussi les données entières 24 et 28 (affichées en octal comme 030 et 034 dans la sortie de la commande od).
Notez que les programmes qui lisent et écrivent directement des structures dans des fichiers ne sont pas portables. Si vous compilez et exécutez le programme writebin.c sur une plateforme, copiez le fichier recfile généré vers une autre plateforme, puis compilez et exécutez le programme readbin.c sur cette plateforme, vous ne pouvez pas garantir que le contenu du fichier sera lu correctement, car différentes plateformes peuvent avoir un ordre des octets différent (et donc stocker les données entières différemment), et le remplissage des structures peut également différer (ainsi le nombre d'octets occupés par la même structure peut différer, et la position du membre age après le membre name peut également différer). En utilisant le programme readrec pour lire le contenu du fichier recfile, cela démontre que le programme writerec a bien écrit les enregistrements dans recfile.
Le contenu lu depuis recfile est le suivant :
Name1: Ken Age1: 24 Name2: Knuth Age2: 28
Exemples d'applications de fwrite et fread :
1. Écrire une chaîne dans un fichier :
char *str="hello,I am a test program!"; fwrite(str,sizeof(char),strlen(str),fp)
2. Écrire un tableau de caractères dans un fichier :
char str[]={'a','b','c','d','e'};
fwrite(str,sizeof(char),sizeof(str),fp)
3. Écrire un tableau d'entiers dans un fichier :
int a[]={12,33,23,24,12};
Calculez d'abord le nombre d'éléments du tableau nmemb, puis
fwrite(a,sizeof(int),nmemb,fp)
Remarque : Comme le fichier généré par le programme est un fichier binaire plutôt qu'un fichier texte, les entiers sont représentés différemment selon les machines, donc le fichier généré ne peut pas être ouvert directement. Vous pouvez utiliser la fonction fread pour vérifier si les données ont été écrites dans le fichier.
URL d'origine : http://purpleroom.blog.sohu.com/133812394.html