为什么循环条件内的 iostream::eof 被认为是错误的（即 `while (!stream.eof())`）？

Question

我刚刚在this 答案中发现了一条评论，说在循环条件中使用iostream::eof 是“几乎肯定是错误的”。我通常使用while(cin>>n) 之类的东西——我猜它会隐式检查 EOF。

为什么使用while (!cin.eof()) 显式检查eof 错误？

它与在 C 中使用 scanf("...",...)!=EOF 有什么不同（我经常使用没有问题）？

Answer 1

因为iostream::eof 只会在读取流的末尾返回true。它确实不表明下一次读取将是流的结尾。

考虑一下（并假设下一次读取将在流的末尾）：

while(!inStream.eof()){
  int data;
  // yay, not end of stream yet, now read ...
  inStream >> data;
  // oh crap, now we read the end and *only* now the eof bit will be set (as well as the fail bit)
  // do stuff with (now uninitialized) data
}

反对：

int data;
while(inStream >> data){
  // when we land here, we can be sure that the read was successful.
  // if it wasn't, the returned stream from operator>> would be converted to false
  // and the loop wouldn't even be entered
  // do stuff with correctly initialized data (hopefully)
}

关于你的第二个问题：因为

if(scanf("...",...)!=EOF)

与

相同

if(!(inStream >> data).eof())

和不一样

if(!inStream.eof())
    inFile >> data

Answer 2

底线顶部：通过正确处理空白，以下是如何使用eof（甚至比fail()更可靠的错误检查）：

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

（感谢 Tony D 提出的突出答案的建议。请参阅下面的评论，了解为什么这更可靠的示例。）

---

反对使用eof() 的主要论点似乎缺少关于空白角色的重要微妙之处。我的主张是，明确地检查eof() 不仅不是“总是错误”——这似乎是这个和类似的 SO 线程中的一个压倒一切的观点——而且正确处理了白色——空间，它提供了更清洁和更可靠的错误处理，并且是始终正确的解决方案（尽管不一定是最简单的）。

总结建议的“正确”终止和阅读顺序如下：

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

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

超出eof的读取尝试失败作为终止条件。这意味着没有简单的方法可以区分成功的流和由于 eof 以外的原因而真正失败的流。采用以下流：

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

while(in>>data) 以一组failbit 结束，用于所有三个输入。在第一个和第三个中，还设置了eofbit。因此，在循环之后，需要非常难看的额外逻辑来区分正确的输入（第一个）和不正确的输入（第二个和第三个）。

然而，采取以下措施：

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

在这里，in.fail() 验证只要有要阅读的内容，它就是正确的。它的目的不仅仅是一个while循环终止符。

到目前为止一切都很好，但是如果流中有尾随空格会发生什么 - 听起来对 eof() 作为终止符的主要担忧是什么？

我们不需要放弃我们的错误处理；只是吃掉空白：

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 在设置eofbit 时跳过流中任何潜在的（零个或多个）尾随空格，不是failbit。因此，in.fail() 可以按预期工作，只要至少有一个数据要读取。如果全空流也可以接受，那么正确的形式是：

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
}

总结：正确构造的while(!eof) 不仅可行且不会出错，而且允许数据在范围内本地化，并提供更清晰的错误检查与常规业务分离。话虽如此，while(!fail) 无疑是一个更常见和更简洁的习语，并且在简单（每个读取类型的单个数据）场景中可能是首选。

Answer 3

因为如果程序员不写while(stream >> n)，他们可能会这样写：

while(!stream.eof())
{
    stream >> n;
    //some work on n;
}

这里的问题是，你不能在不首先检查流读取是否成功的情况下执行some work on n，因为如果不成功，你的some work on n 会产生不希望的结果。

重点在于，eofbit、badbit 或 failbit 是在尝试从流中读取之后设置的。因此，如果 stream >> n 失败，则 @ 987654329@、badbit 或 failbit 会立即设置，因此如果您编写 while (stream >> n)，它会更惯用，因为如果从流中读取失败，则返回的对象 stream 将转换为 false，因此循环停止。如果读取成功并且循环继续，它将转换为true。

Answer 4

其他答案已经解释了为什么while (!stream.eof()) 中的逻辑错误以及如何修复它。我想专注于不同的事情：

为什么使用 iostream::eof 显式检查 eof 错误？

一般来说，检查eof 是错误的，因为流提取 (>>) 可能会失败而不会到达文件末尾。如果你有例如int n; cin >> n; 并且流包含hello，则h 不是有效数字，因此在未到达输入末尾时提取将失败。

这个问题，结合检查流状态的一般逻辑错误在尝试从中读取，这意味着对于 N 个输入项，循环将运行 N+1 次，导致以下症状：

• 如果流为空，循环将运行一次。 >> 将失败（没有要读取的输入）并且所有应该设置的变量（由stream >> x）实际上都未初始化。这会导致处理垃圾数据，这可能表现为无意义的结果（通常是巨大的数字）。

  （如果您的标准库符合 C++11，现在情况有些不同：失败的 >> 现在将数值变量设置为 0，而不是让它们未初始化（chars 除外）。）

• 如果流不为空，循环将在最后一个有效输入后再次运行。由于在上一次迭代中所有>> 操作都失败了，因此变量可能会保留上一次迭代的值。这可以表现为“最后一行被打印两次”或“最后输入记录被处理两次”。

  （自 C++11 以来，这应该会有所不同（见上文）：现在您会得到一个零的“幻像记录”，而不是重复的最后一行。）

• 如果流包含格式错误的数据，但您只检查.eof，您最终会陷入无限循环。 >> 将无法从流中提取任何数据，因此循环在原地旋转而从未到达终点。

---

总结一下：解决方案是测试>> 操作本身是否成功，而不是使用单独的.eof() 方法：while (stream >> n >> m) { ... }，就像在C 中测试scanf 调用本身的成功一样:while (scanf("%d%d", &n, &m) == 2) { ... }.

Answer 5

循环中的 iostream::eof 被认为是错误的，因为我们还没有到达 EOF。所以并不代表下次读取就成功了。

我将通过两个示例代码来解释我的陈述，这肯定会帮助您以更好的方式理解这个概念。比方说，当我们想在 C++ 中使用文件流读取文件时。而当我们使用循环写入文件时，如果我们使用stream.eof()检查文件的结尾，我们实际上是在检查文件是否已经到达结尾。

示例代码

#include<iostream>
#include<fstream>
using namespace std;
int main() {
   ifstream myFile("myfile.txt");
   string x;
   while(!myFile.eof()) {
      myFile >> x;
     // Need to check again if x is valid or eof
     if(x) {
        // Do something with x
     }
   }
}

当我们在循环中直接使用流时，我们不会再次检查条件。

示例代码

#include<iostream>
#include<fstream>
using namespace std;
int main() {
   ifstream myFile("myfile.txt");
   string x;
   while(myFile >> x) {
      // Do something with x
      // No checks needed!
   }
}