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

Question

我刚刚在 这个答案说在循环条件中使用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()更可靠） code> 进行错误检查）：（

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

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

---

反对使用 eof 的主要论点() 似乎遗漏了关于空白的作用的一个重要的微妙之处。我的建议是，显式检查 eof() 不仅不会“总是错误”——这似乎是这个问题和类似的 StackOverflow 问题中的压倒一切的观点——，但通过正确处理空白，它提供了更清晰、更可靠的错误处理，并且是始终正确的解决方案（尽管不一定是最简洁的）。

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

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

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

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

• 1 2 3 4 5
• 1 2 a 3 4 5
• a

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 white space with 'std::ws'
   if ( in.fail() ) /* Handle with 'break' or 'throw' */;
   // Now use data
}

std::ws 在设置 eofbit 时跳过流中任何潜在的（零个或多个）尾随空格，并且不是失败位。因此，只要至少有一个数据需要读取，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;
}

这里的问题是，你不能在没有先对 n 进行some work检查流读取是否成功，因为如果不成功，您对 n 的一些工作将产生不需要的结果。

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

Answer 4

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

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

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

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

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

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

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

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

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

---

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

Answer 5

需要记住的重要一点是，inFile.eof() 在尝试读取之后之前不会变为true失败，因为您已到达文件末尾。因此，在此示例中，您将收到错误。

while (!inFile.eof()){
    inFile >> x;
        process(x);
}

使这个循环正确的方法是将读取和检查合并到一个操作中，就像这样

while (inFile >> x) 
    process(x); 

按照惯例，operator>> 返回我们从中读取的流，并且对流进行布尔测试返回< code>false 当流失败时（例如到达文件末尾）。

所以这给了我们正确的顺序：

• 读取
• 测试读取是否成功
• 当且仅当测试成功时，处理我们读取的内容

如果您碰巧遇到一些其他问题这会阻止您正确读取文件，因此您将无法访问 eof() 。例如，让我们看一下这样的内容

int x; 
while (!inFile.eof()) { 
    inFile >> x; 
    process(x);
} 

让我们通过一个示例来跟踪上述代码的工作过程

• 假设文件的内容是 '1', '2', '3', 'a', ' b'。
• 循环将正确读取 1、2 和 3。
• 然后它会到达a。
• 当它尝试将 a 提取为 int 时，将会失败。
• 该流现在处于失败状态，除非我们清除该流，否则所有读取该流的尝试都将失败。
• 但是，当我们测试 eof() 时，它将返回 false，因为我们还没有到达文件末尾，因为仍然有 a 等待读取。
• 该循环将继续尝试从文件中读取数据，但每次都会失败，因此它永远不会到达文件末尾。
• 因此，上面的循环将永远运行。

但是，如果我们使用这样的循环，我们将得到所需的输出。

while (inFile >> x)
    process(x);

在这种情况下，不仅在文件结束的情况下，而且在转换失败的情况下，流都会转换为 false ，例如我们可以的 a t 读为整数。