Comment fonctionne getchar ()?
Je suis confus par un programme mentionné dans K&R qui utilise getchar(). Il donne la même sortie que la chaîne d'Entrée:
#include <stdio.h>
main(){
int c;
c = getchar();
while(c != EOF){
putchar(c);
c = getchar();
}
}
Pourquoi imprime-t-il toute la chaîne? Je m'attendrais à ce qu'il lise un personnage et demande à nouveau l'entrée.
Et, toutes les chaînes que nous entrons sont-elles terminées par un EOF?
5 réponses
Dans la configuration simple que vous utilisez probablement, getchar fonctionne avec l'entrée tamponnée , vous devez donc appuyer sur Entrée avant que getchar n'obtienne quelque chose à lire. Les chaînes ne sont pas terminées par EOF; en fait, EOF n'est pas vraiment un personnage, mais une valeur magique qui indique la fin du fichier. Mais EOF ne fait pas partie de la chaîne lue. C'est ce que getchar retourne quand il n'y a plus rien à lire.
Il y a un tampon/flux sous-jacent que getchar() et ses amis lisent. Lorsque vous entrez du texte, le texte est stocké dans un tampon quelque part. getchar () peut le parcourir un caractère à la fois. Chaque lecture renvoie le caractère suivant jusqu'à ce qu'il atteigne la fin du tampon. La raison pour laquelle il ne vous demande pas de caractères suivants est qu'il peut extraire le suivant du tampon.
Si vous exécutez votre script et tapez directement dans celui-ci, il continuera à vous demander d'entrer jusqu'à ce que vous appuyez sur CTRL + D (fin du fichier). Si vous l'appelez comme ./ program
Comme un avertissement supplémentaire, je crois que getchar () retournera également EOF s'il rencontre une erreur, donc vous voudrez vérifier ferror (). Exemple ci-dessous (Non testé, mais vous avez l'idée).
main() {
int c;
do {
c = getchar();
if (c == EOF && ferror()) {
perror("getchar");
}
else {
putchar(c);
}
}
while(c != EOF);
}
Cordes, par C définition, sont terminées par '\0'. Vous n'avez pas de "C strings" dans votre programme.
Votre programme lit les caractères (mis en mémoire tampon jusqu'à entrée) à partir de l'entrée standard (le clavier) et les écrit à la sortie standard (l'écran). Il le fait peu importe le nombre de caractères que vous tapez ou pour combien de temps vous le faites.
Pour arrêter le programme, vous devez indiquer que l'entrée standard n'a plus de données (hein?? comment un clavier non plus les données?).
, tapez simplement Ctrl+D (Unix) ou Ctrl+Z (Windows) pour prétendre que le fichier a atteint sa fin.Ctrl+D (ou Ctrl+Z) ne sont pas vraiment des caractères dans le sens C du mot.
Si vous exécutez votre programme avec la redirection d'entrée, les expressions du FOLKLORE est la fin du fichier, et non pas une croyance une./a.out < source.c
Getchar() lit un seul caractère d'entrée et renvoie ce caractère comme valeur de la fonction. S'il y a une erreur lors de la lecture du caractère, ou si la fin de l'entrée est atteinte, getchar() renvoie une valeur spéciale, représentée par "EOF".
Selon la définition de getchar (), il lit un caractère à partir de l'entrée standard. Malheureusement, stdin est confondu avec keyboard, ce qui pourrait ne pas être le cas pour getchar. getchar utilise un tampon comme stdin et lit un seul caractère à la fois. Dans votre cas, puisqu'il n'y a pas EOF, getchar et putchar s'exécutent plusieurs fois et il vous semble que toute la chaîne est imprimée à la fois. faites un petit changement et vous comprendrez:
putchar(c);
printf("\n");
c = getchar();
Regardez maintenant la sortie par rapport au code original.
Un autre exemple qui vous expliquera le concept de getchar et STDIN tamponné:
void main(){
int c;
printf("Enter character");
c = getchar();
putchar();
c = getchar();
putchar();
}
Entrez deux caractères dans le premier cas. La deuxième fois que getchar est en cours d'exécution entrez-vous un personnage? Non, mais encore putchar fonctionne.
Cela signifie finalement qu'il y a un tampon et quand vous tapez quelque chose et cliquez sur Entrée, cela va et s'installe dans le tampon. getchar utilise ce tampon comme stdin.