为什么“while（！feof（file））”总是错的？

时间：2011-03-25 11:42:33

标签： c file while-loop feof

我看到人们最近在很多帖子中试图读取这样的文件。

代码 

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char **argv)
{
    char * path = argc > 1 ? argv[1] : "input.txt";

    FILE * fp = fopen(path, "r");
    if( fp == NULL ) {
        perror(path);
        return EXIT_FAILURE;
    }

    while( !feof(fp) ) {  /* THIS IS WRONG */
        /* Read and process data from file… */
    }
    if( fclose(fp) == 0 ) {
        return EXIT_SUCCESS;
    } else {
        perror(path);
        return EXIT_FAILURE;
    }
}

这个while( !feof(fp))循环有什么问题？

6 个答案:

答案 0 :(得分：410)

我想提供一个抽象的，高层次的视角。

并发和同时性

I / O操作与环境交互。环境不是您的计划的一部分，也不在您的控制之下。环境真正存在＆＃34;同时＆＃34;与您的程序。与所有并发的事情一样，关于＆＃34;当前状态的问题＆＃34;没有意义：没有＆＃34;同时性的概念＆＃34;并发事件。国家的许多财产都不会同时存在。

让我更准确地说：假设你想问，＆＃34;你有更多的数据＆＃34;。您可以询问并发容器或I / O系统。但答案通常是不可行的，因而毫无意义。那么如果容器说＆＃34;是＆＃34; - 当您尝试阅读时，它可能不再有数据。同样，如果答案是＆＃34; no＆＃34;，当您尝试阅读时，数据可能已到达。结论是， 没有像＃34;我有数据＆＃34;这样的属性，因为你不能有效地回应任何可能的答案。 （缓冲输入的情况略好一些，你可以想象得到一个＆＃34;是的，我有数据＆＃34;这构成某种保证，但你仍然必须能够处理相反的情况。对于输出，情况肯定和我描述的一样糟糕：你永远不知道那个磁盘或那个网络缓冲区是否已满。）

因此，我们得出结论，要求I / O系统是否能够执行I / O操作是不可能的，实际上是合理的 。我们可以与它交互的唯一可能方式（就像并发容器一样）是尝试操作并检查它是成功还是失败。在您与环境交互的那一刻，然后才能知道交互是否真的可能，并且此时您必须承诺执行交互。 （这是一个＆＃34;同步点＆＃34;，如果你愿意的话。）

EOF

现在我们到了EOF。 EOF是您从尝试的 I / O操作中获得的响应。这意味着您正在尝试读取或写入某些内容，但在执行此操作时，您无法读取或写入任何数据，而是遇到了输入或输出的结尾。对于基本上所有的I / O API都是如此，无论是C标准库，C ++ iostream还是其他库。只要I / O操作成功，您就只能无法知道是否会有进一步的未来操作成功。您必须始终先尝试操作然后响应成功或失败。

实施例

在每个示例中，请注意我们首先尝试I / O操作，然后使用结果（如果有效）。另请注意，总是必须使用I / O操作的结果，尽管结果在每个示例中都采用不同的形状和形式。

  • C stdio，从文件中读取：

    for (;;) {
    size_t n = fread(buf, 1, bufsize, infile);
    consume(buf, n);
    if (n < bufsize) { break; }
}

    我们必须使用的结果是n，即读取的元素数量（可能只有零）。

  • C stdio，scanf：

    for (int a, b, c; scanf("%d %d %d", &a, &b, &c) == 3; ) {
    consume(a, b, c);
}

    我们必须使用的结果是scanf的返回值，即转换的元素数。

  • C ++，iostreams格式化提取：

    for (int n; std::cin >> n; ) {
    consume(n);
}

    我们必须使用的结果是std::cin本身，可以在布尔上下文中进行评估，并告诉我们流是否仍然处于good()状态。

  • C ++，iostreams getline：

    for (std::string line; std::getline(std::cin, line); ) {
    consume(line);
}

    我们必须使用的结果是std::cin，就像之前一样。

  • POSIX，write(2)刷新缓冲区：

    char const * p = buf;
ssize_t n = bufsize;
for (ssize_t k = bufsize; (k = write(fd, p, n)) > 0; p += k, n -= k) {}
if (n != 0) { /* error, failed to write complete buffer */ }

    我们在这里使用的结果是k，即写入的字节数。这里的要点是我们只能知道在写操作之后写了多少字节。

  • POSIX getline() 

    char *buffer = NULL;
size_t bufsiz = 0;
ssize_t nbytes;
while ((nbytes = getline(&buffer, &bufsiz, fp)) != -1)
{
    /* Use nbytes of data in buffer */
}
free(buffer);

    我们必须使用的结果是nbytes，直到并包括换行符的字节数（如果文件没有以换行符结尾，则为EOF）。

    请注意，当发生错误或达到EOF时，函数显式返回-1（而不是EOF！）。

您可能会注意到我们很少拼出实际的单词＆＃34; EOF＆＃34;。我们通常以某种其他方式检测错误情况，这对我们来说更加有趣（例如，未能按照我们的期望执行尽可能多的I / O）。在每个示例中都有一些API功能可以明确告诉我们已经遇到EOF状态，但事实上这并不是一个非常有用的信息。它比我们经常关心的更详细。重要的是I / O是否成功，而不是失败。

  • 实际查询EOF状态的最后一个示例：假设您有一个字符串，并希望测试它完整表示一个整数，除了空格外没有额外的位。使用C ++ iostream，它是这样的：

    std::string input = "   123   ";   // example

std::istringstream iss(input);
int value;
if (iss >> value >> std::ws && iss.get() == EOF) {
    consume(value);
} else {
    // error, "input" is not parsable as an integer
}

    我们在这里使用两个结果。第一个是iss，即流对象本身，用于检查格式化提取到value是否成功。但是，在消耗空格之后，我们执行另一个I / O /操作iss.get()，并期望它作为EOF失败，如果整个字符串已被格式化提取消耗，则会出现这种情况。

    在C标准库中，您可以通过检查结束指针是否已到达输入字符串的末尾来实现与strto*l函数类似的功能。

答案

while(!eof)是错误的，因为它测试的是无关紧要的内容，无法测试您需要知道的内容。结果是您错误地执行了代码，该代码假定它正在访问已成功读取的数据，而事实上这种情况从未发生过。

答案 1 :(得分：218)

这是错误的，因为（在没有读取错误的情况下）它比作者期望的更多次进入循环。如果存在读取错误，则循环永远不会终止。

请考虑以下代码：

/* WARNING: demonstration of bad coding technique!! */

#include <stdio.h>
#include <stdlib.h>

FILE *Fopen(const char *path, const char *mode);

int main(int argc, char **argv)
{
    FILE *in;
    unsigned count;

    in = argc > 1 ? Fopen(argv[1], "r") : stdin;
    count = 0;

    /* WARNING: this is a bug */
    while (!feof(in)) {  /* This is WRONG! */
        fgetc(in);
        count++;
    }
    printf("Number of characters read: %u\n", count);
    return EXIT_SUCCESS;
}

FILE * Fopen(const char *path, const char *mode)
{
    FILE *f = fopen(path, mode);
    if (f == NULL) {
        perror(path);
        exit(EXIT_FAILURE);
    }
    return f;
}

此程序将始终打印一个大于输入流中字符数的数字（假设没有读取错误）。考虑输入流为空的情况：

$ ./a.out < /dev/null
Number of characters read: 1

在这种情况下，在读取任何数据之前调用feof()，因此返回false。输入循环，调用fgetc()（并返回EOF），并递增计数。然后调用feof()并返回true，导致循环中止。

在所有这些情况下都会发生这种情况。 {<1}}在 之后，在流上的读取遇到文件结尾时才会返回true。 feof()的目的不是检查下一次读取是否会到达文件末尾。 feof()的目的是区分读取错误和到达文件末尾。如果feof()返回0，则必须使用fread() / feof来决定。同样，如果ferror返回fgetc。 EOF仅在 fread返回零或feof()已返回fgetc后才有用。在此之前，EOF将始终返回0.

在调用feof()之前，始终需要检查读取的返回值（fread()，fscanf()或fgetc()）。

更糟糕的是，考虑发生读取错误的情况。在这种情况下，feof()返回fgetc()，EOF返回false，循环永远不会终止。在使用feof()的所有情况下，while(!feof(p))的循环内必须至少有一个检查，或者至少应该用ferror()替换while条件，或者有一个非常真实的无限循环的可能性，可能会在处理无效数据时喷出各种垃圾。

总而言之，虽然我无法肯定地说从来没有写过“while(!feof(p) && !ferror(p))”在语义上正确的情况（尽管必须是另一种检查在循环内部有一个中断以避免读取错误的无限循环），它几乎肯定总是错误的情况。即使一个案例出现在正确的地方，它也是如此惯用，以至于它不是编写代码的正确方法。任何看到该代码的人都应立即犹豫并说“这是一个错误”。并且可能打击作者（除非作者是你的老板，在这种情况下建议自行决定。）

答案 2 :(得分：60)

不，这并不总是错的。如果您的循环条件是“我们还没有尝试读取文件末尾”，那么您使用while (!feof(f))。然而，这不是一个常见的循环条件 - 通常你想测试其他东西（例如“我可以阅读更多”）。 while (!feof(f))没错，只是使用错误。

答案 3 :(得分：29)

feof（）表示是否曾尝试读取文件末尾。这意味着它几乎没有预测效果：如果它是真的，你确定下一个输入操作将失败（你不确定前一个输入操作是否失败），但如果它是假的，你不确定下一个输入操作会成功。此外，输入操作可能由于文件结尾之外的其他原因而失败（格式化输入的格式错误，纯IO故障 - 磁盘故障，网络超时 - 适用于所有输入类型），因此即使您可以预测文件的结尾（任何尝试实现Ada one的人，如果你需要跳过空格，并且它对交互式设备有不良影响，它会告诉你它可能很复杂 - 有时会强迫输入下一个在开始处理前一个行之前，你必须能够处理失败。

因此，C语中的正确习惯是将IO操作成功作为循环条件循环，然后测试失败的原因。例如：

while (fgets(line, sizeof(line), file)) {
    /* note that fgets don't strip the terminating \n, checking its
       presence allow to handle lines longer that sizeof(line), not showed here */
    ...
}
if (ferror(file)) {
   /* IO failure */
} else if (feof(file)) {
   /* format error (not possible with fgets, but would be with fscanf) or end of file */
} else {
   /* format error (not possible with fgets, but would be with fscanf) */
}

答案 4 :(得分：10)

很好的答案，我刚才注意到了同样的事情，因为我试图像这样做一个循环。所以，在这种情况下它是错误的，但是如果你想要一个优雅地结束于EOF的循环，这是一个很好的方法：

#include <stdio.h>
#include <sys/stat.h>
int main(int argc, char *argv[])
{
  struct stat buf;
  FILE *fp = fopen(argv[0], "r");
  stat(filename, &buf);
  while (ftello(fp) != buf.st_size) {
    (void)fgetc(fp);
  }
  // all done, read all the bytes
}

答案 5 :(得分：0)

feof()不是很直观。我非常谦虚地认为，如果任何读取操作导致到达文件末尾，则FILE的文件末尾状态应设置为true。相反，您必须在每次读取操作之后手动检查是否已到达文件末尾。例如，如果使用fgetc()从文本文件中读取内容，类似的事情将起作用：

#include <stdio.h>

int main(int argc, char *argv[])
{
  FILE *in = fopen("testfile.txt", "r");

  while(1) {
    char c = fgetc(in);
    if (feof(in)) break;
    printf("%c", c);
  }

  fclose(in);
  return 0;
}

如果这样的方法可以代替，那就太好了

#include <stdio.h>

int main(int argc, char *argv[])
{
  FILE *in = fopen("testfile.txt", "r");

  while(!feof(in)) {
    printf("%c", fgetc(in));
  }

  fclose(in);
  return 0;
}
相关问题
最新问题