提问



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


代码


#include 
#include 

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))循环有什么问题?

最佳参考


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


并发性和同时性



I/O操作与环境交互。环境不是您的计划的一部分,也不在您的控制之下。环境真正与您的程序同时存在。与所有并发的事情一样,关于当前状态的问题没有意义:并发事件中没有同时性的概念。状态的许多属性根本不同时存在。


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


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


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() [59]


    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!)。



您可能会注意到我们很少拼出实际的单词EOF。我们通常以某种其他方式检测错误条件,这对我们来说更加有趣(例如,未能按照我们的期望执行尽可能多的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


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


请考虑以下代码:


/* WARNING: demonstration of bad coding technique*/

#include 
#include 

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! */
        (void) 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,导致循环中止。


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


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


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


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

其它参考2


不,它并不总是错误的。如果你的循环条件是当我们没有尝试读取文件的末尾时你会使用while (!feof(f))。然而,这不是一个常见的循环条件 - 通常你想测试其他东西(例如我可以阅读更多)。 while (!feof(f))不是错的,只是使用错了。

其它参考3


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


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


#include 
#include 
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
}