¿Por qué "mientras (! Feof (archivo))" siempre es incorrecto?

¿Qué hay de malo en usar feof()para controlar un bucle de lectura? Por ejemplo:

#include <stdio.h>
#include <stdlib.h>

int
main(int argc, char **argv)
{
    char *path = "stdin";
    FILE *fp = argc > 1 ? fopen(path=argv[1], "r") : stdin;

    if( fp == NULL ){
        perror(path);
        return EXIT_FAILURE;
    }

    while( !feof(fp) ){  /* THIS IS WRONG */
        /* Read and process data from file… */
    }
    if( fclose(fp) != 0 ){
        perror(path);
        return EXIT_FAILURE;
    }
    return EXIT_SUCCESS;
}

¿Qué hay de malo en este bucle?

Mar 25 '11 18:03 William Pursell

Está mal porque (en ausencia de un error de lectura) ingresa al bucle una vez más de lo que espera el autor. Si hay un error de lectura, el ciclo nunca termina.

Considere el siguiente código:

/* WARNING: demonstration of bad coding technique!! */

#include <stdio.h>
#include <stdlib.h>

FILE *Fopen(const char *path, const char *mode);

int
main(int argc, char **argv)
{
    FILE *in = argc > 1 ? Fopen(argv[1], "r") : stdin;
    unsigned count = 0;

    /* WARNING: this is a bug */
    while( !feof(in) ) {  /* This is WRONG! */
        fgetc(in);
        count++;
    }
    printf("Number of characters read: %u\n", count);
    return EXIT_SUCCESS;
}

FILE *
Fopen(const char *path, const char *mode)
{
    FILE *f = fopen(path, mode);
    if( f == NULL ) {
        perror(path);
        exit(EXIT_FAILURE);
    }
    return f;
}

Este programa imprimirá consistentemente uno más que el número de caracteres en el flujo de entrada (suponiendo que no haya errores de lectura). Considere el caso en el que el flujo de entrada está vacío:

$ ./a.out < /dev/null
Number of characters read: 1

En este caso, feof()se llama antes de que se hayan leído los datos, por lo que devuelve falso. Se ingresa al bucle, fgetc()se llama (y devuelve EOF) y se incrementa el recuento. Luego feof()se llama y devuelve verdadero, lo que provoca que el ciclo se cancele.

Esto sucede en todos estos casos. feof()no devuelve verdadero hasta que una lectura en la secuencia encuentre el final del archivo. El propósito de feof()NO es verificar si la próxima lectura llegará al final del archivo. El propósito de feof()es determinar el estado de una función de lectura anterior y distinguir entre una condición de error y el final del flujo de datos. Si fread()devuelve 0, debe usar feof/ ferrorpara decidir si ocurrió un error o si se consumieron todos los datos. De manera similar, si fgetcregresa EOF. feof()sólo es útil después de que fread haya devuelto cero o fgetchaya devuelto EOF. Antes de que eso suceda, feof()siempre devolverá 0.

Siempre es necesario verificar el valor de retorno de una lectura (ya sea an fread(), an fscanf()o an fgetc()) antes de llamar feof().

Peor aún, considere el caso en el que se produce un error de lectura. En ese caso, fgetc()devuelve EOF, feof()devuelve falso y el ciclo nunca termina. En todos los casos en los que while(!feof(p))se utiliza, debe haber al menos una verificación dentro del bucle for ferror(), o al menos la condición while debe reemplazarse con while(!feof(p) && !ferror(p))o existe una posibilidad muy real de un bucle infinito, probablemente arrojando todo tipo de basura como se están procesando datos no válidos.

En resumen, aunque no puedo afirmar con certeza que nunca existe una situación en la que pueda ser semánticamente correcto escribir " while(!feof(f))" (aunque debe haber otra verificación dentro del bucle con una interrupción para evitar un bucle infinito en un error de lectura), lo cierto es que es casi seguro que siempre está mal. E incluso si alguna vez surgiera un caso en el que fuera correcto, es tan idiomáticamente incorrecto que no sería la forma correcta de escribir el código. Cualquiera que vea ese código debería dudar inmediatamente y decir "eso es un error". Y posiblemente abofetear al autor (a menos que el autor sea su jefe, en cuyo caso se recomienda discreción).

EDITAR: una forma de escribir el código correctamente, demostrando el uso correcto de feofy ferror:

#include <assert.h>
#include <stdio.h>
#include <stdlib.h>

int
main(int argc, char **argv)
{
    FILE *in = stdin;
    unsigned count = 0;

    while( getc(in) != EOF ){
        count++;
    }
    if( feof(in) ){
        printf("Number of characters read: %u\n", count);
    } else if( ferror(in) ){
        perror("stdin");
    } else {
        assert(0);
    }
    return EXIT_SUCCESS;
}

Mar 25 '2011 12:03 William Pursell

No, no siempre está mal. Si su condición de bucle es "mientras no hemos intentado leer más allá del final del archivo", entonces usa while (!feof(f)). Sin embargo, esta no es una condición de bucle común; por lo general, desea probar algo más (como "¿puedo leer más"). while (!feof(f))no está mal, simplemente se usa mal.

Mar 25 '2011 11:03 Erik

feof()indica si uno ha intentado leer más allá del final del archivo. Eso significa que tiene poco efecto predictivo: si es verdadero, está seguro de que la siguiente operación de entrada fallará (no está seguro de que la anterior falló, por cierto), pero si es falso, no está seguro de la siguiente entrada. la operación tendrá éxito. Además, las operaciones de entrada pueden fallar por otras razones además del final del archivo (un error de formato para la entrada formateada, una falla pura de IO (falla del disco, tiempo de espera de la red) para todos los tipos de entrada), por lo que incluso si pudiera ser predictivo sobre al final del archivo (y cualquiera que haya intentado implementar Ada one, que es predictivo, le dirá que puede ser complejo si necesita omitir espacios y que tiene efectos indeseables en dispositivos interactivos, a veces forzando la entrada del siguiente línea antes de comenzar el manejo de la anterior), tendría que ser capaz de manejar una falla.

Entonces, el modismo correcto en C es realizar un bucle con el éxito de la operación IO como condición del bucle y luego probar la causa del fallo. Por ejemplo:

while (fgets(line, sizeof(line), file)) {
    /* note that fgets don't strip the terminating \n, checking its
       presence allow to handle lines longer that sizeof(line), not showed here */
    ...
}
if (ferror(file)) {
   /* IO failure */
} else if (feof(file)) {
   /* format error (not possible with fgets, but would be with fscanf) or end of file */
} else {
   /* format error (not possible with fgets, but would be with fscanf) */
}

Feb 10 '2012 10:02 AProgrammer

Las otras respuestas a esta pregunta son muy buenas, pero bastante largas. Si solo quieres el TL;DR, es este:

feof(F)esta mal nombrado. No significa "comprobar si ahoraF está al final del archivo "; más bien le indica por qué el intento anterior no pudo obtener ningún dato .F

El estado de fin de archivo puede cambiar fácilmente, porque un archivo puede crecer o reducirse, y un terminal informa EOFuna vez cada vez que presiona ^D(en modo "preparado", en una línea que de otro modo estaría vacía).

A menos que realmente le importe por qué la lectura anterior no devolvió ningún dato, es mejor que olvide que la feoffunción existe.

Oct 20 '2023 00:10 Martin Kealey