Warum ist iostream::eof innerhalb einer Schleife ist die Bedingung (D. H. " beim (!stream.eof())`) als falsch?

Bottom-line-top: Mit der richtigen Handhabung von white-space, das folgende ist, wie eof verwendet werden können (und sogar zuverlässiger als fail() für die Fehlerprüfung):

while( !(in>>std::ws).eof() ) {  
   int data;
   in >> data;
   if ( in.fail() ) /* handle with break or throw */; 
   //now use data
}    

(Dank Tony D für die Anregung zu markieren die Antwort. Siehe sein Kommentar unten für ein Beispiel, warum das so ist robuster.)

Das wichtigste argument gegen die Verwendung von eof() scheint zu sein, fehlt eine wichtige Feinheit, über die Rolle der weißen Raum. Mein Vorschlag ist, dass die überprüfung eof() explizit ist nicht nur nicht "immer falsch" - das scheint zu einem überwiegenden Meinung in diesen und ähnlichen SO threads --, aber mit der richtigen Handhabung von white-space, sorgt es für eine saubere und zuverlässige Fehlerbehandlung, und ist die immer richtig Lösung (obwohl, nicht unbedingt die tersest).

Zusammenfassen, was wird vorgeschlagen, die als die "richtige" Kündigung und lese-Reihenfolge ist folgende:

int data;
while(in >> data) {  /* ... */ }

//which is equivalent to 
while( !(in >> data).fail() )  {  /* ... */ }

Den Ausfall aufgrund von lese-Versuch über eof als Abbruchbedingung. Dies bedeutet, dass es keine einfache Möglichkeit, zu unterscheiden zwischen einem erfolgreichen stream-und eine, die wirklich scheitert aus anderen Gründen als der eof. Nehmen Sie die folgenden Ströme:

• 1 2 3 4 5<eof>
• 1 2 a 3 4 5<eof>
• a<eof>

while(in>>data) endet mit einem Satz failbit für alle drei ein. In der ersten und Dritten, eofbit ist auch gesetzt. Also vorbei an den loop braucht man sehr hässlich zusätzliche Logik zu unterscheiden, dem richtigen input (1.) durch unsachgemäße (2. und 3.).

In der Erwägung, dass die folgenden:

while( !in.eof() ) 
{  
   int data;
   in >> data;
   if ( in.fail() ) /* handle with break or throw */; 
   //now use data
}    

Hier in.fail() überprüft, wie lange, wie es ist, etwas zu Lesen, es ist die richtige. Es ist Ziel ist nicht eine bloße while-loop-terminator.

So weit so gut, aber was passiert, wenn es Leerzeichen im stream -- was sich anhört wie die großen Bedenken gegen eof() als terminator?

Brauchen wir nicht zu kapitulieren unsere Fehler-handling; einfach nur Essen, bis die white-space:

while( !in.eof() ) 
{  
   int data;
   in >> data >> ws; //eat whitespace with std::ws
   if ( in.fail() ) /* handle with break or throw */; 
   //now use data
}

std::ws überspringt alle Potenzial (null oder mehr) Leerzeichen in den Strom während der Einstellung der eofbit, und nicht die failbit. Also in.fail() wie erwartet funktioniert, solange es mindestens einen Daten zu Lesen. Wenn alle-leer-streams sind auch in Ordnung, dann die richtige form ist:

while( !(in>>ws).eof() ) 
{  
   int data;
   in >> data; 
   if ( in.fail() ) /* handle with break or throw */; 
   /* this will never fire if the eof is reached cleanly */
   //now use data
}

Zusammenfassung: Eine richtig konstruierte while(!eof) ist nicht nur möglich und nicht falsch, sondern es erlaubt, Daten lokalisiert werden, die in Umfang, und liefert eine sauberere Trennung der Fehlerprüfung von business as usual. Dass gesagt wird, die while(!fail) ist unbestritten ein häufiger und knappe Sprache, und kann bevorzugt in einfacher (single-Daten-per-Lesen-Typ-Szenarien).

InformationsquelleAutor sly

Die anderen Antworten haben erklärt, warum die Logik ist falsch in while (!stream.eof()) und wie es zu lösen ist. Ich möchte den Fokus auf etwas anderes:

warum ist die überprüfung für eof explizit mit iostream::eof falsch?

Im Allgemeinen, die überprüfung für die eof nur ist falsch, weil Strom-Extraktion (>>) ausfallen kann, ohne auf das Ende der Datei. Wenn Sie z.B. int n; cin >> n; und der stream enthält hello, dann h ist keine gültige Ziffer, also die Extraktion wird fehlschlagen, ohne erreichen des Endes der Eingabe.

Dieses Problem, in Kombination mit der Allgemeinen Logik-Fehler überprüfen Sie den stream-Zustand vor dem Lesen, was bedeutet, dass für die N Eingabe Elemente, die Schleife wird ausgeführt N+1-mal, führt zu der folgenden Symptome:

• Wenn der stream leer ist, wird die Schleife einmal ausgeführt. >> fehl (es ist kein Eingang zu Lesen) und alle Variablen, die angeblich eingestellt werden (durch stream >> x) sind tatsächlich nicht initialisiert. Dies führt zu Datenmüll verarbeitet werden, welche sich dann als unsinnige Ergebnisse (oft riesige zahlen).

• Wenn der stream nicht leer ist, wird die Schleife erneut ausgeführt, nachdem die Letzte gültige Eingabe. Da in der letzten iteration alle >> Operationen fehlschlagen Variablen sind wahrscheinlich zu halten, die Ihren Wert aus der vorherigen iteration. Dies kann sich als "die Letzte Zeile ist zweimal gedruckt" oder "die Letzte input-Datensatz ist doppelt verarbeitet".

• Wenn der stream enthält fehlerhafte Daten, aber Sie prüfen nur für .eof Sie am Ende mit einem unendlichen loop. >> wird scheitern, um zu extrahieren alle Daten aus dem stream, so dass die Schleife dreht sich in Ort, ohne jemals das Ende.

Zur Erinnerung: Die Lösung ist zum testen der Erfolg der >> operation selbst, nicht mit einem separaten .eof() Methode: while (stream >> n >> m) { ... }, genau wie in C-testen Sie den Erfolg der scanf nennen sich selbst: while (scanf("%d%d", &n, &m) == 2) { ... }.

InformationsquelleAutor melpomene