¿Cómo usar EOF para ejecutar a través de un archivo de texto en C?

Tengo un archivo de texto que tiene cadenas en cada línea. Quiero incrementar un número para cada línea en el archivo de texto, pero cuando llega al final del archivo, obviamente necesita detenerse. Intenté investigar sobre EOF, pero no pude entender cómo usarlo correctamente.

Supongo que necesito un ciclo while, pero no estoy seguro de cómo hacerlo.

La forma en que detecta EOF depende de lo que esté usando para leer la transmisión:

function result on EOF or error -------- ---------------------- fgets() NULL fscanf() number of succesful conversions less than expected fgetc() EOF fread() number of elements read less than expected 

Verifique el resultado de la llamada de entrada para la condición apropiada anterior, luego llame a feof() para determinar si el resultado fue debido a golpear EOF o algún otro error.

Usando fgets() :

  char buffer[BUFFER_SIZE]; while (fgets(buffer, sizeof buffer, stream) != NULL) { // process buffer } if (feof(stream)) { // hit end of file } else { // some other error interrupted the read } 

Usando fscanf() :

 char buffer[BUFFER_SIZE]; while (fscanf(stream, "%s", buffer) == 1) // expect 1 successful conversion { // process buffer } if (feof(stream)) { // hit end of file } else { // some other error interrupted the read } 

Usando fgetc() :

 int c; while ((c = fgetc(stream)) != EOF) { // process c } if (feof(stream)) { // hit end of file } else { // some other error interrupted the read } 

Usando fread() :

 char buffer[BUFFER_SIZE]; while (fread(buffer, sizeof buffer, 1, stream) == 1) // expecting 1 // element of size // BUFFER_SIZE { // process buffer } if (feof(stream)) { // hit end of file } else { // some other error interrupted read } 

Tenga en cuenta que el formulario es el mismo para todos ellos: verifique el resultado de la operación de lectura; si falló, luego verifique EOF. Verás muchos ejemplos como:

 while(!feof(stream)) { fscanf(stream, "%s", buffer); ... } 

Este formulario no funciona de la forma en que las personas piensan que lo hace, porque feof() no volverá verdadero hasta después de que haya intentado leer más allá del final del archivo. Como resultado, el ciclo se ejecuta una vez más, lo que puede o no causarle un poco de dolor.

Un posible lazo C sería:

 #include  int main() { int c; while ((c = getchar()) != EOF) { /* ** Do something with c, such as check against '\n' ** and increment a line counter. */ } } 

Por ahora, ignoraría feof y funciones similares. Exprience muestra que es demasiado fácil llamarlo en el momento equivocado y procesar algo dos veces en la creencia de que eof aún no se ha alcanzado.

Peligro a evitar: usar char para el tipo de c. getchar devuelve el siguiente molde de personaje a un unsigned char y luego a un int . Esto significa que en la mayoría de las plataformas [sanas] el valor de EOF y los valores ” char ” válidos en c no se superponen, por lo que nunca detectará accidentalmente EOF para un carácter “normal”.

Debería verificar el EOF después de leer el archivo.

 fscanf_s // read from file while(condition) // check EOF { fscanf_s // read from file }