Warum “while (!feof(Datei))" immer falsch???

Ich würde gerne eine abstrakte, high-level-Perspektive.

Parallelität und Gleichzeitigkeit

I/O-Operationen mit der Umwelt interagieren. Die Umgebung ist nicht Teil des Programms, und nicht unter Ihrer Kontrolle. Die Umwelt existiert wirklich "gleichzeitig" mit Ihrem Programm. Wie mit allen Dingen gleichzeitig, Fragen über den "aktuellen Stand" machen keinen Sinn: Es gibt kein Konzept von "Gleichzeitigkeit" über gleichzeitige Ereignisse. Viele Eigenschaften, die der Staat einfach nicht existieren gleichzeitig.

Lassen Sie mich dies genauer: Angenommen, Sie wollen, zu Fragen, "haben Sie noch mehr Daten". Man könnte diese Frage einer gleichzeitigen container, oder von Ihrem I/O-system. Aber die Antwort ist in der Regel unactionable, und damit bedeutungslos. Was also, wenn der container sagt "ja" – durch die Zeit, die Sie versuchen zu Lesen, es können keine Daten mehr habe. Ebenso, wenn die Antwort "Nein" ist, durch die Zeit, die Sie versuchen zu Lesen, können die Daten angekommen sind. Die Schlussfolgerung ist, dass es einfach ist keine Eigenschaft wie "ich habe die Daten", da Sie nicht handeln kann sinnvoll in Antwort auf eine mögliche Antwort. (Die situation ist etwas besser mit Gepufferter Eingang, wo Sie könnten möglicherweise Holen Sie sich ein "ja, ich habe Daten" , stellt eine Art Garantie, aber Sie würde immer noch in der Lage, sich mit den entgegengesetzten Fall. Und mit dem Ausgang der situation ist sicherlich genauso schlecht wie ich es beschrieben: man weiß nie, wenn die Festplatte oder das Netzwerk-Puffer voll ist.)

So können wir daraus folgern, dass es unmöglich ist, und in der Tat un - angemessenen, bitten die I/O-system, ob es werden in der Lage zum ausführen einer I/O-operation. Die einzig mögliche Art, wie wir mit ihm interagieren können (genau wie mit einer gleichzeitigen container) Versuch den Betrieb und überprüfen, ob es erfolgreich war oder nicht. In diesem moment, wo Sie interagieren mit der Umgebung, dann, und nur dann kann man wissen, ob die Interaktion tatsächlich möglich war, und an diesem Punkt müssen Sie einen commit für die Durchführung der Interaktion. (Dies ist eine "synchronisation point", wenn man so will.)

EOF

Nun kommen wir zum EOF. EOF ist die Antwort man von einer versucht I/O-operation. Es bedeutet, dass Sie versuchen zu Lesen oder etwas schreiben, aber wenn Sie dies tun, Sie konnte nicht Lesen oder schreiben Sie alle Daten, und stattdessen das Ende des Eingabe-und Ausgabe festgestellt wurde. Dies gilt im wesentlichen für alle I/O-APIs, ob es der C-standard-Bibliothek C++ iostreams, oder anderen Bibliotheken. Solange die I/O-Operationen erfolgreich sind, Sie einfach nicht wissen, ob weitere, zukünftige Operationen gelingt. Sie muss immer zuerst versuchen, den Betrieb und die antwortet dann für Erfolg oder Misserfolg.

Beispiele

In jedem der Beispiele, beachten Sie sorgfältig, dass wir ersten versuchen, die I/O-operation und dann verbrauchen das Ergebnis, wenn es gültig ist. Beachten Sie weiterhin, dass wir immer muss das Ergebnis der I/O-operation, wenn das Ergebnis nimmt verschiedene Formen und Formen in jedem Beispiel.

• C stdio, die aus einer Datei gelesen:

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

  Dem Ergebnis, das wir verwenden müssen, ist n die Anzahl der Elemente, die gelesen wurden, (die möglicherweise als kleiner als null).

• C stdio, scanf:

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

  Dem Ergebnis, das wir verwenden müssen, ist der return-Wert von scanf die Anzahl der Elemente umgewandelt.

• C++ iostreams formatiert Extraktion:

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

  Dem Ergebnis, das wir verwenden müssen, ist std::cin selbst, die ausgewertet werden können, die in einem booleschen Kontext und sagt uns, ob der stream ist noch in der good() Zustand.

• C++ iostreams getline:

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

  Dem Ergebnis, das wir verwenden müssen, ist wieder std::cin wie vor.

• POSIX, write(2) flush-Puffer:

  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 */ }

  Dem Ergebnis, das wir hier benutzen, ist k, die Anzahl der geschriebenen bytes. Der Punkt hier ist, dass wir nur wissen, wie viele bytes geschrieben wurden nach der write-operation.

• 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);

  Dem Ergebnis, das wir verwenden müssen, ist nbytes, die Anzahl der bytes bis einschließlich der newline (oder EOF, wenn die Datei nicht am Ende mit einem Zeilenumbruch).

  Beachten Sie, dass die Funktion explizit zurück -1 (und nicht EOF!) wenn ein Fehler Auftritt oder EOF erreicht.

Können Sie feststellen, dass wir sehr selten buchstabieren das Wort "EOF". Wir erkennen in der Regel den Fehler in irgendeiner anderen Weise, die mehr sofort interessant für uns (z.B. Nichterfüllung, so viel I/O, wie wir es gewünscht hatte). In jedem Beispiel gibt es einige API-Funktion, die konnte uns sagen ausdrücklich, dass die EOF-Zustand aufgetreten, dieser ist aber in der Tat keine sehr hilfreiche information. Es ist viel mehr ein detail als wir oft kümmern. Was zählt, ist, ob die I/O gelang es, so mehr, als, wie es scheiterte.

• Einem letzten Beispiel, dass eigentlich fragt den EOF-Status: Angenommen Sie haben einen string und möchten, um zu testen, ob es für eine ganze Zahl in seiner Gesamtheit, mit keine zusätzlichen bits am Ende, außer whitespace-Zeichen. Mit C++ iostreams, es geht so:

  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
  }

  Wir verwenden zwei Ergebnisse hier. Die erste ist iss, das stream-Objekt selbst, um zu überprüfen, dass die formatierten Extraktion zu value gelungen. Aber dann, nachdem auch konsumieren Leerzeichen, führen wir ein weiteres I/O/Betrieb iss.get(), und erwarten, dass es zu scheitern, wie EOF, das ist der Fall, wenn der gesamte string hat, die bereits verbraucht worden, die von der formatierten Extraktion.

  In der C-standard-Bibliothek, die Sie erreichen können, etwas ähnliches mit dem strto*l Funktionen, indem Sie die Ende-Zeiger erreicht das Ende der Eingabezeichenfolge.

Die Antwort

while(!eof) ist falsch, weil es tests für etwas, was irrelevant ist und nicht testen, für etwas, das Sie brauchen, um wissen. Das Ergebnis ist, dass Sie fälschlicherweise code ausführen, wird davon ausgegangen, dass es beim Zugriff auf die Daten, die erfolgreich gelesen, wenn in der Tat dies nie passiert ist.

InformationsquelleAutor Kerrek SB

Nein, es ist nicht immer falsch. Wenn Ihre Schleifenbedingung "while wir habe nicht versucht, zu Lesen hinter Dateiende", dann verwenden Sie while (!feof(f)). Dies ist jedoch nicht eine gemeinsame Schleife-Bedingung - in der Regel, die Sie testen möchten für etwas anderes (wie "kann ich mehr"). while (!feof(f)) ist nicht falsch, es ist nur verwendet falsch.

InformationsquelleAutor Erik

Super Antwort, ich habe gerade bemerkt, die gleiche Sache, weil ich versuche zu tun, eine Schleife so. Also, es ist falsch, dass Szenario, aber wenn Sie möchten, um eine Schleife, die anmutig endet am EOF, dies ist ein schöner Weg, es zu tun:

#include <stdio.h>
#include <sys/stat.h>
int main(int argc, char *argv[])
{
  struct stat buf;
  FILE *fp = fopen(argv[0], "r");
  stat(filename, &buf);
  while (ftello(fp) != buf.st_size) {
    (void)fgetc(fp);
  }
  //all done, read all the bytes
}

InformationsquelleAutor tesch1