Warum wird iostream :: eof in einer Schleifenbedingung als falsch angesehen?

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 eofbitund 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 der Antwort sly

1 while (!read.fail()) {
2     cout << ch;
3     read.get(ch);
4 }

Wenn Sie mit der Linie 2 in 3 und Zeile 3 im 2 erhalten Sie ch zweimal gedruckt.
Also cout vorher Lesen.

InformationsquelleAutor der Antwort Mohammed Younus