Pourquoi le "while (!feof (fichier))" toujours tort?

j'aimerais vous présenter une perspective abstraite et de haut niveau.

simultanéité et simultanéité

opérations d'e/S interagir avec l'environnement. L'environnement ne fait pas partie de votre programme, et non pas sous votre contrôle. L'environnement existe vraiment "simultanément" avec votre programme. Comme pour tout ce qui est concurrent, les questions sur "l'état actuel" n'ont pas de sens: il n'y a pas de concept de "simultanéité" entre les événements concurrents. Beaucoup les propriétés de l'état tout simplement ne existent concurremment.

permettez-moi de préciser: supposez que vous voulez demander, "Avez-vous plus de données". Vous pouvez demander cela d'un conteneur concurrent, ou de votre système D'e/s. Mais la réponse est généralement inacceptable, et donc dénuée de sens. Ainsi, que faire si le conteneur dit "oui" – au moment où vous essayez de lire, il peut ne plus avoir de données. De même, si la réponse est "non", au moment où vous essayez de lecture, les données peuvent avoir arriver. La conclusion est qu'il simplement est aucune propriété comme" j'ai des données", car vous ne pouvez pas agir de manière significative en réponse à toute réponse possible. (La situation est légèrement meilleure avec tampon d'entrée, où vous pourriez éventuellement obtenir un "oui, j'ai des données" qui constitue une sorte de garantie, mais vous auriez encore être en mesure de traiter le cas contraire. Et avec la sortie la situation est certainement aussi mauvaise que je l'ai décrit: on ne sait jamais si ce disque ou le tampon réseau est plein.)

nous pouvons Donc conclure qu'il est impossible, et, en fait, de l'onu raisonnable , à demander à un système d'e/S s'il sera capable d'effectuer une opération d'e/S. La seule façon possible d'interagir avec elle (tout comme avec un conteneur concurrent) est de tenter l'opération et de vérifier si elle a réussi ou échoué. Au moment où vous interagissez avec l'environnement, puis et c'est seulement alors que vous pouvez savoir si l'interaction était réellement possible, et à ce moment-là vous devez vous engager à effectuer l'interaction. (C'est une "synchronisation", si vous voulez.)

expressions du FOLKLORE

maintenant nous arrivons à L'EOF. EOF est le réponse vous obtenez d'un tentative opération D'e / s. Cela signifie que vous essayiez de lire ou d'écrire quelque chose, mais en le faisant, vous avez échoué à lire ou à écrire données, et à la place la fin de l'entrée ou de la sortie a été rencontrée. Cela est vrai pour l'essentiel de tous les API D'e / s, qu'il s'agisse de la bibliothèque C standard, de C++ iostream ou d'autres bibliothèques. Tant que les opérations D'E/S réussiront, vous ne pouvez pas savoir si d'autres opérations futures réussiront. Vous doit toujours d'abord essayer l'opération et puis répondre à la réussite ou l'échec.

Exemples

dans chacun des exemples, notez attentivement que nous d'abord essayer l'opération d'E/S et puis consommer le résultat si elle est valide. Notez en outre que nous toujours doit utiliser le résultat de l'opération d'e/s, bien que le résultat prend différentes formes et formes dans chaque exemple.

• C stdio, lire à partir d'un fichier:

  for (;;) {
      size_t n = fread(buf, 1, bufsize, infile);
      consume(buf, n);
      if (n < bufsize) { break; }
  }
  

  le résultat nous devons utiliser est n , le nombre d'éléments qui ont été lus (qui peut être aussi peu que zéro).

• c stdio, scanf :

  for (int a, b, c; scanf("%d %d %d", &a, &b, &c) == 3; ) {
      consume(a, b, c);
  }
  

  le résultat que nous devons utiliser est la valeur de retour de scanf , le nombre d'éléments convertis.

• C++, iostreams formaté extraction:

  for (int n; std::cin >> n; ) {
      consume(n);
  }
  

  le résultat que nous devons utiliser est std::cin elle - même, qui peut être évaluée dans un contexte booléen et nous dit si le flux est encore dans l'état good() .

• C++, iostreams getline:

  for (std::string line; std::getline(std::cin, line); ) {
      consume(line);
  }
  

  le résultat que nous devons utiliser est à nouveau std::cin , comme avant.

• POSIX, write(2) pour rincer un tampon:

  char const * p = buf;
  ssize_t n = bufsize;
  for (ssize_t k = bufsize; (k = write(fd, p, n)) > 0; p += k, n -= k) {}
  if (n != 0) { /* error, failed to write complete buffer */ }
  

  Le résultat que nous utilisons ici est k , le nombre d'octets écrits. Le point ici est que nous ne pouvons savoir combien d'octets ont été écrits après l'opération d'écriture.

• POSIX getline()

  char *buffer = NULL;
  size_t bufsiz = 0;
  ssize_t nbytes;
  while ((nbytes = getline(&buffer, &bufsiz, fp)) != -1)
  {
      /* Use nbytes of data in buffer */
  }
  free(buffer);
  

  le résultat que nous devons utiliser est nbytes , le nombre d'octets jusqu'à et y compris la nouvelle ligne (ou EOF si le fichier ne s'est pas terminé par une nouvelle ligne).

  noter que la fonction renvoie explicitement -1 (et non EOF!) lorsqu'une erreur se produit ou qu'elle atteint EOF.

vous remarquerez que nous épelons très rarement le vrai mot"EOF". Nous détectons habituellement la condition d'erreur d'une autre manière qui est plus immédiatement intéressante pour nous (par exemple l'incapacité à effectuer autant d'e/s que nous l'avions souhaité). Dans chaque exemple, il y a une fonction API qui pourrait nous indiquer explicitement que L'état EOF a été rencontré, mais c'est dans le fait n'est pas une information très utile. C'est un détail bien plus important que ce dont nous nous soucions souvent. Ce qui importe, c'est de savoir si le premier lieutenant a réussi, plus que de savoir comment il a échoué.

• un dernier exemple qui interroge en fait L'état EOF: supposons que vous ayez une chaîne de caractères et que vous vouliez tester qu'elle représente un entier dans son intégralité, sans bits supplémentaires à la fin sauf les espaces. En utilisant C++ iostreams, il va comme ceci:

  std::string input = "   123   ";   // example
  
  std::istringstream iss(input);
  int value;
  if (iss >> value >> std::ws && iss.get() == EOF) {
      consume(value);
  } else {
      // error, "input" is not parsable as an integer
  }
  

  Nous utilisons deux résultats ici. La première est iss , l'objet stream lui-même, pour vérifier que l'extraction formatée à value réussi. Mais ensuite, après avoir également consommé de l'espace, nous effectuons une autre opération d'e / s, iss.get() , et nous nous attendons à ce qu'elle échoue comme EOF, ce qui est le cas si la chaîne entière a déjà été consommée par l'extraction formatée.

  dans la bibliothèque standard C vous pouvez obtenir quelque chose de similaire avec le strto*l fonctions en vérifiant que la fin pointeur a atteint la fin de la chaîne d'entrée.

la réponse

while(!eof) est erroné parce qu'il teste pour quelque chose qui n'est pas pertinent et échoue à tester pour quelque chose que vous devez savoir. Le résultat est que vous exécutez par erreur du code qui suppose qu'il est l'accès aux données qui a été lu avec succès, alors qu'en fait, cela ne s'est jamais produit.