Problème avec L'EOF in C

EOF n'est pas un caractère - c'est une valeur spéciale que les fonctions d'entrée retournent pour indiquer une condition , que la "fin du fichier" sur ce flux d'entrée a été atteint. Comme le dit Martin v. Löwis, une fois que cette condition de "fin de fichier" se produit, cela signifie qu'aucune entrée ne sera plus disponible sur ce flux.

la confusion naît parce que:

• plusieurs types de terminaux reconnaissent une touche spéciale pour signaler la "fin du fichier" lorsque le "fichier" est un terminal interactif (p. ex. Ctrl-Z ou Ctrl-D); et
• la valeur EOF est l'une des valeurs qui peuvent être retournées par la famille de fonctions getchar() .

vous aurez besoin d'utiliser une valeur de caractère réelle pour séparer les entrées - le caractère ASCII nul '"151930920"' pourrait être un bon choix, si cela ne peut pas apparaître comme une valeur valide dans les entrées elles-mêmes.

j'exécute le code sur ma machine linux, voici le résultat:

Enter a: qwer
asdf<Ctrl-D><Ctrl-D>
Enter b: 123
456<Ctrl-D><Ctrl-D>

Results:
a: qwer
asdf
b: 123
456

deux Ctrl-d étaient nécessaires parce que le tampon d'entrée terminal n'était pas vide.

, Vous pouvez utiliser le caractère nul ( '"151900920"' ) pour séparer les variables. Divers outils UNIX (par exemple find ) sont capables de séparer leurs articles de sortie de cette façon, ce qui suggère que c'est une méthode assez standard.

un autre avantage de ceci est que vous pouvez lire le flux dans un tampon simple et puis créer un tableau de char* s pour pointer vers les chaînes individuelles, et chaque chaîne sera correctement '" 151900920 "' - terminé sans vous devez changer n'importe quoi dans le tampon manuellement. Cela signifie moins de frais généraux d'allocation de mémoire, ce qui peut faire fonctionner votre programme sensiblement plus rapidement en fonction du nombre de variables que vous lisez. Bien sûr, cela n'est nécessaire que si vous avez besoin de garder toutes les variables en mémoire en même temps - si vous avez affaire à eux un par un, vous n'obtenez pas cet avantage particulier.

ce que vous essayez est fondamentalement impossible avec L'EOF.

bien qu'il se comporte comme un à certains égards, EOF n'est pas un caractère dans le flux, mais une macro définie par l'environnement représentant la fin du flux. Je n'ai pas vu votre code, mais je suppose que vous faites quelque chose comme ça:

while ((c=getchar()) != EOF) {
    // do something
}
while ((c=getchar()) != EOF) {
    // do something else
}

quand vous tapez le caractère EOF la première fois, pour terminer la première chaîne, le flux est irrévocablement fermé. Qui est, le statut du ruisseau est qu'il est fermé.

ainsi, le contenu de la seconde boucle while ne s'exécute jamais.

plutôt que d'arrêter la lecture à L'entrée EOF -- qui n'est pas un caractère -- arrêtez-vous à ENTER.

while((c = getchar()) != '\n')
{
    if (c == EOF) /* oops, something wrong, input terminated too soon! */;
    a[x] = c;
    x++;
}

EOF est un signal que la saisie terminée. Vous êtes presque sûr que toutes les entrées de l'utilisateur se terminent par '\n': c'est la dernière touche que l'utilisateur tape!!!

Edit: vous pouvez toujours utiliser Ctrl-D et clearerr() pour réinitialiser le flux d'entrée.

#include <stdio.h>

int main(void) {
  char a[100], b[100];
  int c, k;

  printf("Enter a: "); fflush(stdout);
  k = 0;
  while ((k < 100) && ((c = getchar()) != EOF)) {
    a[k++] = c;
  }
  a[k] = 0;

  clearerr(stdin);

  printf("Enter b: "); fflush(stdout);
  k = 0;
  while ((k < 100) && ((c = getchar()) != EOF)) {
    b[k++] = c;
  }
  b[k] = 0;

  printf("a is [%s]; b is [%s]\n", a, b);
  return 0;
}

$ ./a.out
Enter a: two
lines (Ctrl+D right after the next ENTER)
Enter b: three
lines
now (ENTER + Ctrl+D)
a is [two
lines (Ctrl+D right after the next ENTER)
]; b is [three
lines
now (ENTER + Ctrl+D)
]
$

comment inscrire null dans le programme?

vous pouvez implémenter la fonction-print0 en utilisant:

putchar(0);

ceci imprimera un caractère ASCII nul '\0' à sdtout.