¿Qué es EOF en el lenguaje de progtwigción C?

¿Cómo se llega a ver la última copia? En otras palabras, ¿qué poner para EOF? Revisé las definiciones y dice que EOF es -1.

Y si ingresas Ctrl-D, no verás nada.

#include  int main() { int c; while((c = getchar() != EOF)) { printf("%d\n", c); } printf("%d - at EOF\n", c); } 

En sistemas Linux y OS X, el carácter a ingresar para causar un EOF es CtrlD . Para Windows, es CtrlZ.

Dependiendo del sistema operativo, este personaje solo funcionará si es el primer carácter en una línea, es decir, el primer carácter después de un Enter . Como la entrada de la consola a menudo está orientada a la línea, es posible que el sistema no reconozca el carácter EOF hasta después de haber seguido con un Enter .

Y sí, si ese personaje es reconocido como un EOF, entonces tu progtwig nunca verá el personaje real. En cambio, un progtwig C obtendrá un -1 de getchar() .

Debes cambiar tu paréntesis para

 while((c = getchar()) != EOF) 

Porque el operador “=” tiene una prioridad menor que el operador “! =”. Entonces obtendrás los resultados esperados. Tu expresión es igual a

 while (c = (getchar()!= EOF)) 

Obtendrá los dos 1 como salida, porque está haciendo la comparación “c! = EOF”. Esto siempre será uno para el personaje que ingresaste y luego el “\ n” que sigue al presionar return. Excepto por la última comparación donde c realmente es EOF, le dará un 0.

EDIT sobre EOF: EOF es típicamente -1, pero esto no está garantizado por el estándar. La norma solo define sobre EOF en la sección 7.19.1:

EOF que se expande a una expresión constante de enteros, con tipo int y un valor negativo, que es devuelto por varias funciones para indicar fin de archivo, es decir, no más entrada de una secuencia;

Es razonable suponer que EOF es igual a -1, pero cuando usa EOF no debe probar contra el valor específico, sino más bien usar la macro.

El valor de EOF es un entero negativo para distinguirlo de los valores “char” que están en el rango de 0 a 255. Suele ser -1, pero podría ser cualquier otro número negativo … de acuerdo con las especificaciones POSIX, por lo que no debe suponer que es -1.

El carácter ^ D es lo que escribe en una secuencia de consola en UNIX / Linux para indicarle que termine lógicamente una secuencia de entrada. Pero en otros contextos (como cuando estás leyendo desde un archivo) es simplemente otro personaje de datos. De cualquier manera, el carácter ^ D (es decir, el final de la entrada) nunca llega al código de la aplicación.

Como dice @Bastien, EOF también se devuelve si getchar() falla. Estrictamente hablando, debe llamar a ferror o feof para ver si el EOF representa un error o un final de transmisión. Pero en la mayoría de los casos su aplicación hará lo mismo en ambos casos.

EOF significa fin de archivo. Es un signo de que se llega al final de un archivo y de que ya no habrá más datos.

Editar:

Estoy corregido. En este caso, no es un final de archivo. Como se mencionó, se pasa cuando se pasa CTRL + d (linux) o CTRL + z (windows).

Par de errores tipográficos:

 while((c = getchar())!= EOF) 

en lugar de:

 while((c = getchar() != EOF)) 

También getchar () trata una tecla de retorno como una entrada válida, por lo que debe almacenarla también. EOF es un marcador que indica el final de la entrada. Generalmente es un int con todos los bits establecidos.

 #include  int main() { int c; while((c = getchar())!= EOF) { if( getchar() == EOF ) break; printf(" %d\n", c); } printf("%d %u %x- at EOF\n", c , c, c); } 

huellas dactilares:

  49
 50
 -1 4294967295 ffffffff- en EOF 

para la entrada:

 1
 2
 

La entrada de un terminal nunca termina realmente (a menos que el dispositivo esté desconectado), pero es útil ingresar más de un “archivo” en un terminal, por lo que una secuencia de teclas se reserva para indicar el final de la entrada. En UNIX, la traducción de la tecla a EOF es realizada por el controlador del terminal, por lo que un progtwig no necesita distinguir terminales de otros archivos de entrada. De forma predeterminada, el controlador convierte un carácter de Control-D al comienzo de una línea en un indicador de fin de archivo. Para insertar un carácter real de Control-D (ASCII 04) en el flujo de entrada, el usuario lo antecede con un carácter de comando “quote” (generalmente Control-V). AmigaDOS es similar pero usa Control- \ en lugar de Control-D.

En DOS y Windows de Microsoft (y en CP / M y muchos sistemas operativos DEC), la lectura desde el terminal nunca producirá un EOF. En cambio, los progtwigs reconocen que la fuente es una terminal (u otro “dispositivo de caracteres”) e interpretan un carácter o secuencia reservada como un indicador de fin de archivo; lo más común es que sea ASCII Control-Z, código 26. Algunos progtwigs MS-DOS, incluidas partes del shell de Microsoft MS-DOS (COMMAND.COM) y los progtwigs de utilidad del sistema operativo (como EDLIN), tratan un Control-Z en un archivo de texto como marcar el final de datos significativos, y / o anexar un Control-Z al final cuando se escribe un archivo de texto. Esto se hizo por dos razones:

  1. Compatibilidad hacia atrás con CP / M. El sistema de archivos CP / M solo registraba las longitudes de los archivos en múltiplos de “registros” de 128 bytes, por lo que, por convención, se utilizaba un carácter de Control-Z para marcar el final de los datos significativos si terminaban en el medio de un registro. El sistema de archivos de MS-DOS siempre ha registrado la longitud exacta de bytes de los archivos, por lo que nunca fue necesario en MS-DOS.

  2. Permite a los progtwigs utilizar el mismo código para leer la entrada de un terminal y un archivo de texto.

 #include  int main() { int c; while((c = getchar()) != EOF) { //precedence of != is greater than =, so use braces printf("%d\n", c); } printf("%d - at EOF\n", c); } 

Creo que esta es la forma correcta de verificar el valor de EOF. Y revisé la salida.

Para INPUT: abc y Enter obtuve OUTPUT: 97 98 99 10. (los valores ASCII)

Para INPUT Ctrl-D obtuve OUTPUT: -1 – en EOF. Entonces, creo que -1 es el valor de EOF.

Pruebe con otras entradas en lugar de Ctrl-D, como Ctrl-Z. Creo que varía de comstackdor a comstackdor.

 #include  int main() { int c; while((c = getchar()) != EOF) { putchar(c); } printf("%d at EOF\n", c); } 

modificó el código anterior para dar más claridad en EOF, presione Ctrl + d y putchar se usa para imprimir el carácter de char evitar el uso de printf dentro del ciclo while.

 int c; while((c = getchar())!= 10) { if( getchar() == EOF ) break; printf(" %d\n", c); }