为什么iostream :: eof在循环条件内（即（！stream.eof（））`）认为是错误的？

Question

我刚刚在此回答说在循环条件下使用iostream :: eof使用“几乎肯定是错误的”。我通常使用（cin＆gt;＆gt; n）的之类的东西 - 我想它会隐含地检查EOF。

为什么在（！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> 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（）明确的不仅不是“ 总是错误的”，这似乎是在此和类似的堆栈中的一个偏高的意见但是，通过正确处理白色空间，它可以提供更清洁，更可靠的错误处理，并且始终是正确的解决方案（尽管不一定是束缚）。

总结为“适当”终止和阅读顺序所建议的内容如下：

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

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

以EOF超出EOF的读数为终止条件。这意味着没有简单的方法可以区分成功的流和由于EOF以外的其他原因而失败的流。进行以下流：

• 1 2 3 4 5＆lt; eof＆gt;
• 1 2 A 3 4 5＆lt; eof＆gt;
• a＆lt; eof＆gt; eof＆gt;

while（in＆gt; gt; data）用set failbit for 全部三个输入终止。在第一和第三，也设置了eofbit。因此，过去的循环需要非常丑陋的额外逻辑，以将适当的输入（第一个）与不当的输入（第二和第三）区分开。

鉴于，以下内容：

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

此处，in.fail（）验证只要有东西要读取，它是正确的。目的不仅仅是，而循环终结器。

到目前为止还算不错，但是如果流中有尾随空间，这听起来像是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 时跳过流中的任何潜力（零或更多），而不是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
}

摘要：正确构造的，而（！数据将在范围内定位，并像往常一样提供了从业务检查的错误分离。话虽这么说，<代码>（！fail）是无疑是一个更常见的和简短的成语，并且可以在简单的（每个读取类型的单一读）方案中首选。

Answer 3

因为如果程序员不编写while（stream＆gt;＆gt; n），他们可能会写下此：

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

这里的问题是，您不能在没有先行的情况下进行上的某些工作检查流读取是否成功，因为如果不成功，您的n上的一些工作将产生不期望的结果。

重点是，eofbit，badbit或failbit在尝试从流中读取后，设置了。<<<<<<<<<<<<< /strong>因此，如果流＆gt;＆gt; n失败，然后eofbit，badbit 或failbit是立即设置的，因此，如果您在编写时，则更加惯用（流＆gt;＆gt; n），因为返回的对象流将转换为false如果从流中阅读出现故障，因此循环停止。如果读取成功并且循环继续进行，则它将转换为true 。

Answer 4

其他答案解释了为什么逻辑在中是错误的，而（！stream.eof（））以及如何修复它。我想专注于不同的东西：

为什么要使用iostream :: eof错误检查EOF？

一般而言，检查eof 唯一的是错误的，因为流提取（＆gt;＆gt;＆gt;）可能会失败而不会击中文件的结尾。如果您有Eg int n; cin＆gt;＆gt; n;和流包含hello，然后h不是有效的数字，因此提取将失败而不到达输入结束。

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

• < p>如果流为空，则循环将运行一次。 ＆gt;＆gt;将失败（没有要读取的输入），并且所有应该设置的变量（通过stream＆gt;＆gt; x）均为非机密化。这会导致处理垃圾数据，这可能表现为荒谬的结果（通常数量很大）。

  （如果您的标准库符合C ++ 11，那么现在情况有所不同：一个失败的＆gt;＆gt;现在将数字变量设置为0而不是使它们非专业化（char s除外）

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

  （由于C ++ 11，这应该有所不同（请参见上文）：现在您获得了零的“幻影记录”，而不是重复的最后一行。）

• 如果该流包含错误的数据，但是您只检查<<<<代码> .eof ，您最终会获得无限循环。 ＆gt;＆gt;将无法从流中提取任何数据，因此循环旋转而无需达到末端。

---

回顾：解决方案是测试＆gt;＆gt;操作本身的成功，不使用单独＆gt;＆gt; n＆gt;＆gt; m）{...} 一样％d％d“，＆amp; n，＆amp; m）== 2）{...} 。

Answer 5

要记住的重要一点是，infile.eof（）不会变成true，直到 失败，因为您已经到达了文件的末尾。因此，在此示例中，您会遇到一个错误。

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

使此循环正确的方法是将阅读和检查结合到一个单个操作中，例如

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

按照惯例，运营商＆gt;＆gt;返回我们从中读取的流，以及在流返回的布尔值测试<代码> false 流程失败时（例如，到达文件的末尾）。

因此，这给了我们正确的顺序：

• 读取
• 测试是否在且仅当测试成功时才能成功
• 请处理我们阅读的内容

，请处理我们遇到的某些其他问题， 这样可以防止您正确从文件中读取，因此您将无法达到eof（）。例如，让我们看一下类似的内容

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

，让我们跟踪上述代码的工作，其中一个示例

• 假设文件的内容为'1'，'2'，'2'，'3'，'a'，'' B'。
• 循环将正确读取1、2和3。
• 然后，它将进入a。
• 当它试图将a提取为int时，它将失败。
• 现在，该流处于失败状态，直到我们clear流中，所有从中读取的尝试都将失败。
• 但是，当我们测试eof（）时，它将返回false，因为我们不在文件末尾，因为仍然有a等待读取。
• 循环将继续尝试从文件中读取，并每次失败，因此它永不达到文件的末尾。
• 因此，上面的循环将永远运行。

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

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

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