Qu'est-ce que EOF dans le langage de programmation C?
https://stackoverflow.com/questions/1782080
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianQuestion
Comment obtenez-vous de voir la dernière impression? En d'autres termes ce qu'il faut mettre en pour EOF? J'ai vérifié les définitions et il dit EOF est -1.
Et si vous entrez Ctrl-D vous ne verrez rien.
#include <stdio.h>
int main() {
int c;
while((c = getchar() != EOF)) {
printf("%d\n", c);
}
printf("%d - at EOF\n", c);
}
La solution
Sur les systèmes Linux et OS X, le caractère d'entrée pour provoquer un EOF est Ctrl - D . Pour Windows, il est Ctrl -. Z
En fonction du système d'exploitation, ce personnage ne fonctionnera que si elle est le premier caractère sur une ligne, à savoir le premier caractère après un Entrée . Depuis l'entrée de la console est souvent orientée vers la ligne, le système peut aussi ne pas reconnaître le caractère EOF jusqu'à ce que vous avez suivi avec un Entrée .
Et oui, si ce caractère est reconnu comme un EOF, votre programme ne verra jamais le caractère réel. Au lieu de cela, un programme C recevra un -1 de getchar().
Autres conseils
Vous devez changer votre parenthèses à
while((c = getchar()) != EOF)
Parce que l'opérateur de « = » a une priorité inférieure à l'opérateur « ! = ». Ensuite, vous obtiendrez les résultats escomptés. Votre expression est égale à
while (c = (getchar()!= EOF))
Vous obtenez les deux 1 en sortie, parce que vous faites la comparaison « c! = EOF ». Ce sera toujours un pour devenir le personnage que vous avez entré, puis le « \ n » qui suit en appuyant sur le retour. À l'exception de la dernière comparaison où c est vraiment EOF il vous donnera un 0.
EDIT au sujet EOF: EOF est généralement -1, mais cela ne garantit pas la norme. La norme définit seulement EOF dans la section 7.19.1:
EOF qui se dilate à un nombre entier expression constante de type int et une valeur négative, qui est renvoyée par plusieurs fonctions pour indiquer de fin de fichier, qui est, pas plus d'entrée d'un courant;
Il est raisonnable de supposer que EOF est égal à -1, mais lorsque vous utilisez EOF vous ne devriez pas tester contre la valeur spécifique, mais plutôt utiliser la macro.
La valeur de EOF est un entier négatif pour le distinguer des valeurs « char » qui sont dans la plage de 0 à 255. Il est généralement -1, mais il pourrait être tout autre nombre négatif ... selon les spécifications POSIX , vous ne devriez pas supposer qu'il est -1.
Le ^ D caractère est ce que vous tapez dans un flux de la console sous UNIX / Linux pour lui dire de mettre fin logiquement un flux d'entrée. Mais dans d'autres contextes (comme lorsque vous lisez à partir d'un fichier), il est juste un autre caractère de données. De toute façon, le caractère ^ D (ce qui signifie la fin de l'entrée) ne rend le code d'application.
Comme le dit @Bastien, EOF est également renvoyée si getchar() échoue. Au sens strict, vous devez appeler ferror ou feof pour voir si le EOF représente une erreur ou une fin de flux. Mais dans la plupart des cas, votre application va faire la même chose dans les deux cas.
EOF signifie la fin du fichier. Il est un signe que la fin d'un fichier est atteint, et qu'il n'y aura pas de données plus.
Modifier
Je me suis trompé. Dans ce cas, ce n'est pas une fin de fichier. Comme mentionné, il est transmis lorsque CTRL + d (Linux) ou CTRL + z (fenêtres) passe.
Couple de fautes de frappe:
while((c = getchar())!= EOF)à la place de:
while((c = getchar() != EOF))getchar également () traite une clé de retour comme une entrée valide, vous devez tampon il too.EOF est un marqueur pour indiquer la fin de l'entrée. En général, il est un int avec tous les bits.
#include <stdio.h>
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- at EOF
pour l'entrée:
1 2 <ctrl-d>
nput d'un terminal jamais vraiment « extrémités » (à moins que le dispositif est déconnecté), mais il est utile d'entrer dans plus d'un « fichier » dans un terminal, donc une séquence de touches est réservé pour indiquer la fin de l'entrée. Dans UNIX la traduction de la combinaison de touches à EOF est effectuée par le conducteur terminal, donc un programme n'a pas besoin de distinguer les terminaux d'autres fichiers d'entrée. Par défaut, le pilote convertit un caractère de contrôle-D au début d'une ligne dans un indicateur de fin de fichier. Pour insérer un caractère de contrôle-D réel (ASCII 04) dans le flux d'entrée, l'utilisateur précède avec un caractère de commande « citation » (généralement Ctrl-V). AmigaDOS est similaire, mais utilise contrôle- \ au lieu de contrôle-D.
Dans DOS de Microsoft et Windows (et CP / M et de nombreux systèmes d'exploitation DEC), la lecture du terminal ne produira jamais un EOF. Au lieu de cela, les programmes reconnaissent que la source est un terminal (ou un autre « dispositif de caractère ») et interpréter un caractère réservé donnée ou d'une séquence comme une fin de fichier indicateur; le plus souvent c'est un contrôle-Z ASCII, le code 26. Certains programmes MS-DOS, y compris les parties de la coque Microsoft MS-DOS (COMMAND.COM) et les programmes utilitaires du système d'exploitation (tels que EDLIN), traiter un contrôle-Z dans un fichier de texte comme marquant la fin des données significatives, et / ou ajouter un Control-Z à l'extrémité lors de l'écriture d'un fichier texte. Cela a été fait pour deux raisons:
compatibilité descendante avec CP / M. Le système de fichiers CP / M ne sont enregistrées les longueurs des fichiers en multiples de 128 octets « enregistrements », donc par convention un caractère de contrôle-Z a été utilisé pour marquer la fin des données significatives si elle a pris fin au milieu d'un enregistrement. Le système de fichiers MS-DOS a toujours enregistré l'exacte octet longueur des fichiers, donc cela n'a jamais été nécessaire sur MS-DOS.
Il permet aux programmes d'utiliser le même code pour lire l'entrée à la fois un terminal et un fichier texte.
#include <stdio.h>
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 cela est juste moyen de vérifier la valeur de EOF. Et j'ai vérifié la sortie.
Pour INPUT: abc et entrez je suis arrivé SORTIE: 97 98 99 10. (les valeurs ASCII)
Pour l'entrée Ctrl-D je suis arrivé SORTIE: -1 - à EOF. Je pense donc que -1 est la valeur de EOF.
Essayez d'autres entrées au lieu de Ctrl-D, comme Ctrl-Z. Je pense que cela varie d'un compilateur de compilateur.
pour le garder simple: EOF est un type entier avec la valeur -1. Par conséquent, nous devons utiliser une variable entière pour tester EOF.
#include <stdio.h>
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 l'éviter char à l'aide printf dans les while.
int c;
while((c = getchar())!= 10)
{
if( getchar() == EOF )
break;
printf(" %d\n", c);
}
