Qu’est-ce que EOF dans le langage de programmation C?

Comment voyez-vous la dernière impression? En d’autres termes, que faut-il mettre pour EOF? J’ai vérifié les définitions et il est écrit que EOF est -1.

Et si vous entrez Ctrl-D, vous ne verrez rien.

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

Sur les systèmes Linux et OS X, le caractère à saisir pour provoquer un EOF est CtrlD . Pour Windows, c’est CtrlZ.

Selon le système d’exploitation, ce caractère ne fonctionnera que s’il s’agit du premier caractère d’une ligne, c’est-à-dire le premier caractère après une entrée . Etant donné que l’entrée de la console est souvent orientée ligne, le système peut également ne pas reconnaître le caractère EOF avant de l’avoir suivi avec une entrée .

Et oui, si ce caractère est reconnu en tant que fin de fichier, votre programme ne verra jamais le caractère réel. Au lieu de cela, un programme C obtiendra un -1 de getchar() .

Vous devriez changer votre parenthèse en

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

Parce que l’opérateur “=” a une priorité inférieure à l’opérateur “! =”. Ensuite, vous obtiendrez les résultats attendus. Votre expression est égale à

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

Vous obtenez les deux 1 en sortie, car vous effectuez la comparaison “c! = EOF”. Cela deviendra toujours un pour le caractère que vous avez entré, puis le “\ n” qui suit en appuyant sur retour. Sauf pour la dernière comparaison où c est vraiment EOF, il vous donnera un 0.

EDIT about EOF: EOF vaut généralement -1, mais cela n’est pas garanti par la norme. La norme définit uniquement à propos de EOF dans la section 7.19.1:

EOF qui se développe en une expression constante entière, de type int et une valeur négative, renvoyée par plusieurs fonctions pour indiquer la fin du fichier, c’est-à-dire qu’il n’y a plus d’entrées dans un stream;

Il est raisonnable de supposer que EOF est égal à -1, mais lorsque vous utilisez EOF, vous ne devez pas effectuer de test sur la valeur spécifique, mais utilisez plutôt la macro.

La valeur de EOF est un entier négatif permettant de la distinguer des valeurs “char” comsockets entre 0 et 255. Il s’agit généralement de -1, mais il peut s’agir de tout autre nombre négatif … en fonction des spécifications POSIX. ne devrait pas supposer que c’est -1.

Le caractère ^ D correspond à ce que vous tapez dans un stream de console sous UNIX / Linux pour lui indiquer de mettre fin logiquement à un stream d’entrée. Mais dans d’autres contextes (comme lorsque vous lisez un fichier), il ne s’agit que d’un autre caractère de données. Quoi qu’il en soit, le caractère ^ D (signifiant la fin de la saisie) ne passe jamais au code de l’application.

Comme @Bastien le dit, EOF est également renvoyé si getchar() échoue. À proprement parler, vous devez appeler ferror ou feof pour savoir si le fichier EOF représente une erreur ou une fin de stream. Mais dans la plupart des cas, votre application fera la même chose dans les deux cas.

EOF signifie fin de fichier. C’est un signe que la fin d’un fichier est atteinte et qu’il n’y aura plus de données.

Modifier:

Je me suis trompé. Dans ce cas, ce n’est pas une fin de fichier. Comme mentionné, il est passé lorsque CTRL + d (Linux) ou CTRL + z (Windows) est passé.

Couple de fautes de frappe:

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

au lieu de:

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

De plus, getchar () considère une clé de retour comme une entrée valide. Vous devez donc également la mettre en mémoire tampon. EOF est un marqueur pour indiquer la fin de l’entrée. Généralement, il s’agit d’un entier avec tous les bits.

 #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); } 

impressions:

  49
 50
 -1 4294967295 ffffffff- à EOF 

pour l’entrée:

 1
 2
 

La sortie d’un terminal ne “termine” jamais vraiment (sauf si le périphérique est déconnecté), mais il est utile de saisir plusieurs “fichiers” dans un terminal, une séquence de touches est donc réservée pour indiquer la fin de la saisie. Sous UNIX, la traduction de la frappe en EOF est effectuée par le pilote de terminal. Par conséquent, un programme n’a pas besoin de distinguer les terminaux des autres fichiers d’entrée. Par défaut, le pilote convertit un caractère Control-D au début d’une ligne en un indicateur de fin de fichier. Pour insérer un caractère Control-D (ASCII 04) réel dans le stream d’entrée, l’utilisateur le précède d’un caractère de commande “quote” (généralement Control-V). AmigaDOS est similaire mais utilise Control- \ au lieu de Control-D.

Sous DOS et Windows de Microsoft (et dans CP / M et de nombreux systèmes d’exploitation DEC), la lecture à partir du terminal ne produira jamais d’EOF. Au lieu de cela, les programmes reconnaissent que la source est un terminal (ou un autre “périphérique de caractère”) et interprètent un caractère ou une séquence réservé donné comme un indicateur de fin de fichier; le plus souvent, il s’agit d’un contrôle-Z ASCII, code 26. Certains programmes MS-DOS, y compris des parties du shell Microsoft MS-DOS (COMMAND.COM) et des programmes utilitaires de système d’exploitation (tels que EDLIN), traitent un Control-Z. dans un fichier texte comme marquant la fin des données significatives, et / ou ajoutez un Control-Z à la fin lors de l’écriture d’un fichier texte. Cela a été fait pour deux raisons:

  1. Rétrocompatibilité avec CP / M. Le système de fichiers CP / M n’enregistrait que la longueur des fichiers dans des multiples de “enregistrements” de 128 octets; ainsi, par convention, un caractère Control-Z était utilisé pour marquer la fin des données significatives s’il se terminait au milieu d’un enregistrement. Le système de fichiers MS-DOS a toujours enregistré la longueur exacte en octets des fichiers. Cela n’a donc jamais été nécessaire sous MS-DOS.

  2. Il permet aux programmes d’utiliser le même code pour lire les entrées d’un terminal et d’un fichier texte.

 #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); } 

Je pense que c’est une bonne façon de vérifier la valeur de EOF. Et j’ai vérifié la sortie.

Pour INPUT: abc et Enter j’ai obtenu OUTPUT: 97 98 99 10. (les valeurs ASCII)

Pour INPUT Ctrl-D, j’ai obtenu OUTPUT: -1 – à EOF. Donc, je pense que -1 est la valeur pour EOF.

Essayez d’autres entrées au lieu de Ctrl-D, comme Ctrl-Z. Je pense que cela varie d’un compilateur à l’autre.

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

modifié le code ci-dessus pour donner plus de clarté sur EOF, appuyez sur Ctrl + d et putchar est utilisé pour imprimer le caractère, évitez d’utiliser printf dans la boucle while.

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