fclose valeur de retour case

De comp.lang.c:

La fonction fclose() l'appel peut échouer, et devrait
erreur vérifié tout comme assidûment
comme toutes les autres opérations sur les fichiers.
Sons pédant, droit? Mal. Dans un
ancienne vie, mes produits de l'entreprise
réussi à détruire les données d'un client
en omettant d'un chèque pour défaut lorsque
fermeture d'un fichier. La séquence est allé
quelque chose comme (paraphrasé):

stream = fopen(tempfile, "w"); 
if (stream == NULL) ... 
    while (more_to_write) 
        if (fwrite(buffer, 1, buflen, stream) != buflen) ... 
fclose (stream); 

/* The new version has been written successfully.  Delete 
 * the old one and rename. 
 */ 
remove (realfile); 
rename (tempfile, realfile); 

Bien sûr, ce qui s'est passé
la fonction fclose() a couru hors de l'espace disque en essayant
pour écrire les deux derniers blocs de
de données, de sorte que le "fichier temporaire" a été tronqué
et inutilisable. Et puisque la fonction fclose()
l'échec n'était pas détecté, le programme
allés de l'avant et détruit l'
la meilleure version existante de données dans
faveur de la version endommagée. Et, comme
Murphy aurait-il, la victime dans
cet incident a été l'
personne en charge du client
département, la personne ayant autorité
pour acheter plus de notre produit ou le remplacer
avec les produits d'un concurrent --
et, natch, une personne qui a déjà été
malheureux avec nous pour d'autres raisons.

Ce serait un tronçon à attribuer tous les de
le suivi de la misère à cette seule
l'omission, mais il peut être intéressant de souligner
que à la fois le client et mon
ancienne société ont disparu depuis
à partir de l'entreprise de l'écologie.

VÉRIFIEZ LES CODES DE PANNE!

1. fclose() va vider les non écrites de sortie (via fflush()) avant de revenir, de sorte que l'erreur des résultats de la sous-jacentes write() ne sera pas reporté à fwrite() ou fprintf() temps, mais quand vous faites le fclose(). En conséquence, toute erreur qui write() ou fflush() peut générer peuvent être générés par fclose().

2. fclose() également appel close() qui peut générer des erreurs sur les clients NFS, où le changement de fichier n'est pas téléchargé vers le serveur distant jusqu'à ce que close() temps. Si le serveur NFS s'est écrasé, puis les close() sera un échec, et donc fclose() échoue également. Cela peut être vrai pour d'autres systèmes de fichiers en réseau.

Disons que vous êtes la production de données. Vous avez de vieilles données que vous fread() à partir d'un fichier, et ensuite effectuer un traitement sur les données, générer plus de données, et puis les écrire dans un nouveau fichier. Vous êtes prudent de ne pas écraser l'ancien fichier, car vous savez que d'essayer de créer un nouveau fichier peut échouer, et vous souhaitez conserver vos anciennes données dans ce cas (certaines données, c'est mieux que pas de données). Après avoir terminé tous les fwrite()s, qui tout réussi (parce que vous méticuleusement vérifié la valeur de retour de fwrite()), vous fclose() le fichier. Ensuite, vous rename() votre juste écrit fichier et d'écraser l'ancien fichier.

Si fclose() échoué en raison d'une erreur d'écriture (disque plein?), vous avez juste a remplacé votre dernière bonne fichier avec quelque chose qui pourrait être indésirable. Oups.

Donc, si il est essentiel, vous devez vérifier la valeur de retour de fclose().

En termes de code:

#include <stdio.h>
#include <stdlib.h>
int main(void)
{
FILE *ifp = fopen("in.dat", "rb");
FILE *ofp = fopen("out.dat", "wb");
char buf[BUFSIZ];
size_t n;
int success = 1;
if (ifp == NULL) {
fprintf(stderr, "error opening in.dat\n");
perror("in.dat");
return EXIT_FAILURE;
}
if (ofp == NULL) {
fclose(ifp);
fprintf(stderr, "error opening out.dat\n");
perror("out.dat");
return EXIT_FAILURE;
}
while ((n = fread(buf, 1, sizeof buf, ifp)) > 0) {
size_t nw;
if ((nw = fwrite(buf, 1, n, ofp)) != n) {
fprintf(stderr, "error writing, wrote %lu bytes instead of %lu\n",
(unsigned long)n,
(unsigned long)nw);
fclose(ifp);
fclose(ofp);
return EXIT_FAILURE;
}
}
if (ferror(ifp)) {
fprintf(stderr, "ferror on ifp\n");
fclose(ofp);
fclose(ifp);
return EXIT_FAILURE;
}
#ifdef MAYLOSE_DATA
fclose(ofp);
fclose(ifp);
rename("out.dat", "in.dat"); /* Oops, may lose data */
#else
if (fclose(ofp) == EOF) {
perror("out.dat");
success = 0;
}
if (fclose(ifp) == EOF) {
perror("in.dat");
success = 0;
}
if (success) {
rename("out.dat", "in.dat"); /* Good */
}
#endif
return EXIT_SUCCESS;
}

Dans le code ci-dessus, nous avons été prudents fopen(), fwrite(), et fread(), mais même alors, pas de vérification de fclose() peut entraîner la perte de données (lors de la compilation avec MAYLOSE_DATA défini).

J'ai vu de nombreuses fois à la fonction fclose() de retour non nulle.

Et un examen attentif de constater que le problème avec l'écriture et de ne pas fclose.

Depuis les trucs écrits sont mis en mémoire tampon avant réelle écriture qui se passe et quand une fonction fclose() est appelé tout le tampon est vidé. De sorte que tout problème dans l'écriture de la mémoire tampon suff, disent que le disque est plein, apparaît au cours de la fonction fclose(). Comme David Crier dit, à écrire une balle de preuve de l'application, vous devez tenir compte de la valeur de retour de la fonction fclose().

Si, dans le contexte de votre demande, vous pouvez penser à quelque chose d'utile à faire si la fonction fclose() échoue, puis de tester la valeur de retour. Si vous ne pouvez pas, ne pas.