eof_eoferror - CSDN
eof 订阅
EOF是一个计算机术语,为End Of File的缩写,在操作系统中表示资料源无更多的资料可读取。资料源通常称为档案或串流。通常在文本的最后存在此字符表示资料结束。 展开全文
EOF是一个计算机术语,为End Of File的缩写,在操作系统中表示资料源无更多的资料可读取。资料源通常称为档案或串流。通常在文本的最后存在此字符表示资料结束。
信息
全    称
End Of File
应    用
档案存取
外文名
EOF
释    义
资料源无更多的资料可读取
中文名
文件结束符
学    科
计算机
EOF概述
从一个终端的输入从来不会真的“结束”(除非设备被断开),但把从终端输入的数据分区成多个“文件”却很有用,因此一个关键的序列被保留下来来指明输入结束。在UNIX和AmigaDOS中,将击键翻译为EOF的过程是由终端的驱动程序完成的,因此应用程序无需将终端和其它输入文件区分开来。Unix平台的驱动程序在行首传送一个传输结束字符(Control-D,ASCII编码为为04)来指明文件结束。在AmigaDOS中,驱动程序传送一个Control-\来指明文件结束(而Control-D被用作中断字符)。要向输入流中插入一个真正的Control-D字符,用户需要把一个“引用”命令字符放在它的前面(通常是Control-V,表示下一个字符不作为控制字符,而是按照字面量使用)。在微软的DOS和Windows(以及CP/M和许多DEC操作系统)中,读取数据时终端不会产生EOF。此时,应用程序知道数据源是一个终端(或者其它“字符设备”),并将一个已知的保留的字符或序列解释为文件结束的指明;最普遍地说,它是ASCII码中的替换字符(Control-Z,代码26)。一些MS-DOS程序,包括部分微软MS-DOS的shell(COMMAND.COM)和操作系统功能程序(如EDLIN),将文本文档中的Control-Z视为有意义数据的结尾,并且/或者在写入文本文档时将Control-Z添加到文档末尾。这是由于两个原因:
收起全文
精华内容
参与话题
  • EOF的意义及用法(while(scanf("%d",&n) != EOF))

    万次阅读 多人点赞 2020-02-09 21:28:28
    EOF,为End Of File的缩写,通常在文本的最后存在此字符表示资料结束。 在微软的DOS和Windows中,读取数据时终端不会产生EOF。此时,应用程序知道数据源是一个终端(或者其它“字符设备”),并将一个已知的保留的...

    EOF,为End Of File的缩写,通常在文本的最后存在此字符表示资料结束。
    在微软的DOS和Windows中,读取数据时终端不会产生EOF。此时,应用程序知道数据源是一个终端(或者其它“字符设备”),并将一个已知的保留的字符或序列解释为文件结束的指明;最普遍地说,它是ASCII码中的替换字符(Control-Z,代码26)。
    在C语言中,或更精确地说成C标准函数库中表示文件结束符(end of file)。在while循环中以EOF作为文件结束标志,这种以EOF作为文件结束标志的文件,必须是文本文件。在文本文件中,数据都是以字符的ASCII代码值的形式存放。我们知道,ASCII代码值的范围是0~127,不可能出现-1,因此可以用EOF作为文件结束标志。
    档案存取或其它 I/O 功能可能传回等于象征符号值 (巨集) EOF 指示档案结束的情形发生。实际上 EOF 的值通常为 -1,但它依系统有所不同。巨集 EOF会在编译原始码前展开实际值给预处理器。
    C语言中,EOF常被作为文件结束的标志。还有很多文件处理函数处错误后的返回值也是EOF,因此常被用来判断调用一个函数是否成功。
    例如:

    #include <stdio.h>
    int main(){
    	int n;
    while(scanf("%d",&n) != EOF){ 
    	
    }
    	return 0;
    }
    

    当上面的程序运行时,如果不加" != EOF",那么这个程序就是个死循环,会一直运行下去;加上" != EOF"后该程序就不是死循环了,如果在终端不进行输入该程序会自动结束(while的意思就是说当当前输入缓存还有东西时就一直读取,直到输入缓存中的内容为空时停止)。
    在这"scanf("%d",&n) != EOF"相当于"scanf("%d",&n) != EOF",或"~scanf("%d",&n)",或"scanf("%d",&n) == 1 " 。scanf的返回值由后面的参数决定

    有小伙伴会问到上面那个程序怎么结束呢?
    要注意的是:在终端(黑框)中手动输入时,系统并不知道什么时候到达了所谓的“文件末尾”,因此需要用<Ctrl + z>组合键然后按 Enter 键的方式来告诉系统已经到了EOF,这样系统才会结束while.

    scanf("%d%d", &a, &b);
    如果a和b都被成功读入,那么scanf的返回值就是2;如果只有a被成功读入,返回值为1;如果a和b都未被成功读入,返回值为0;如果遇到错误或遇到end of file,返回值为EOF,且返回值为int型。

    但是在C++中不存在这种用法,但相同作用的有while((cin >> a) != 0):
    以前不理解在while里面用cin >> a;是什么意思,cin是C++的输入流对象,">>"是重载的运算符,cin>>的返回值是cin对象。用这个当条件的话,通过检测其流的状态来判断结束;
    (1)若流是有效的,即流未遇到错误,那么检测成功;
    (2)若遇到文件结束符,或遇到一个无效的输入时(例如本题输入的值不是一个整数),istream对象的状态会变为无效,条件就为假;读取失败的时候,就不能继续读取了,那么读取操作结束,while(cin>>a)就返回false,跳出循环!
    C++中的while (cin>>n,n):
    他的作用是:输入一个数,这数不为0时进入循环,为0时跳出循环。

    采纳:“https://www.cnblogs.com/tgycoder/p/4958519.html”

    输入(cin)缓冲是行缓冲。当从键盘上输入一串字符并按回车后,这些字符会首先被送到输入缓冲区中存储。每当按下回车键后,cin 就会检测输入缓冲区中是否有了可读的数据,这种情况下cin对键盘上是否有作为流结束标志CTRL+Z或者CTRL+D,其检查的方式有两种:阻塞式以及非阻塞式。

    阻塞式检查方式指的是只有在回车键按下之后才对此前是否有 Ctrl+Z 组合键按下进行检查,非阻塞式样指的是按下 Ctrl+D 之后立即响应的方式。如果在按 Ctrl+D 之前已经从键盘输入了字符,则 Ctrl+D的作用就相当于回车,即把这些字符送到输入缓冲区供读取使用,此时Ctrl+D不再起流结束符的作用。如果按 Ctrl+D 之前没有任何键盘输入,则 Ctrl+D 就是流结束的信号。
    阻塞式的方式有一个特点:只有按下回车之后才有可能检测在此之前是否有Ctrl+Z按下。

    参考:百度百科。

    展开全文
  • EOF

    千次阅读 2013-08-26 08:30:18
    >> 关于文件结束符EOF EOF 是 End Of File 的缩写。 在C语言中,它是在标准库中定义的一个宏。 人们经常误认为 EOF 是从文件中读取的一个字符(牢记)。其实,EOF 不是一个字符,它被定义为是 int 类型的一个...
    >> 关于文件结束符EOF
    EOF 是 End Of File 的缩写。

    在C语言中,它是在标准库中定义的一个宏。

    人们经常误认为 EOF 是从文件中读取的一个字符(牢记)。其实,EOF 不是一个字符,它被定义为是 int 类型的一个负数(比如 -1)。EOF 也不是文件中实际存在的内容。EOF 也不是只表示读文件到了结尾这一状态(这种状态可以用 feof() 来检测),它还能表示 I/O 操作中的读、写错误(通常可以用 ferror() 来检测)以及其它一些关联操作的错误状态。

    一、getchar的两点总结:
    1.getchar是以行为单位进行存取的。
    当用getchar进行输入时,如果输入的第一个字符为有效字符(即输入不是文件结束符EOF,Windows下为组合键Ctrl+Z,Unix/Linux下为组合键Ctrl+D),那么只有当最后一个输入字符为换行符'/n'(也可以是文件结束符EOF,EOF将在后面讨论)时,getchar才会停止执行,整个程序将会往下执行。譬如下面程序段:

    while((c =getchar())!=EOF){
        putchar(c);
    }


    执行程序,输入:abc,然后回车。则程序就会去执行puchar(c),然后输出abc,这个地方不要忘了,系统输出的还有一个回车。然后可以继续输入,再次遇到换行符的时候,程序又会把那一行的输入的字符输出在终端上。

    对于getchar,肯定很多初学的朋友会问,getchar不是以字符为单位读取的吗?那么,既然我输入了第一个字符a,肯定满足while循环(c = getchar()) != EOF的条件阿,那么应该执行putchar(c)在终端输出一个字符a。不错,我在用getchar的时候也是一直这么想的,但是程序就偏偏不着样执行,而是必需读到一个换行符或者文件结束符EOF才进行一次输出。对这个问题的一个解释是,在大师编写C的时候,当时并没有所谓终端输入的概念,所有的输入实际上都是按照文件进行读取的,文件中一般都是以行为单位的。因此,只有遇到换行符,那么程序会认为输入结束,然后采取执行程序的其他部分。同时,输入是按照文件的方式存取的,那么要结束一个文件的输入就需用到EOF(Enf Of File). 这也就是为什么getchar结束输入退出时要用EOF的原因。
    2.getchar()的返回值一般情况下是字符,但也可能是负值,即返回EOF。

    这里要强调的一点就是,getchar函数通常返回终端所输入的字符,这些字符系统中对应的ASCII值都是非负的。因此,很多时候,我们会写这样的两行代码:

    char c;
    c =getchar();



    这样就很有可能出现问题。因为getchar函数除了返回终端输入的字符外,在遇到Ctrl+D(Linux下)即文件结束符EOF时,getchar()的返回EOF,这个EOF在函数库里一般定义为-1。因此,在这种情况下,getchar函数返回一个负值,把一个负值赋给一个char型的变量是不正确的。为了能够让所定义的变量能够包含getchar函数返回的所有可能的值,正确的定义方法如下(K&R C中特别提到了这个问题):

    int c;
    c =getchar();

    二、EOF的两点总结(主要指普通终端中的EOF)
    1.EOF作为文件结束符时的情况:

    EOF虽然是文件结束符,但并不是在任何情况下输入Ctrl+D(Windows下Ctrl+Z)都能够实现文件结束的功能,只有在下列的条件下,才作为文件结束符。
    (1)遇到getcahr函数执行时,要输入第一个字符时就直接输入Ctrl+D,就可以跳出getchar(),去执行程序的其他部分;
    (2)在前面输入的字符为换行符时,接着输入Ctrl+D;
    (3)在前面有字符输入且不为换行符时,要连着输入两次Ctrl+D,这时第二次输入的Ctrl+D起到文件结束符的功能,至于第一次的Ctrl+D的作用将在下面介绍。
    其实,这三种情况都可以总结为只有在getchar()提示新的一次输入时,直接输入Ctrl+D才相当于文件结束符。


    2.EOF作为行结束符时的情况,这时候输入Ctrl+D并不能结束getchar(),而只能引发getchar()提示下一轮的输入。

    这种情况主要是在进行getchar()新的一行输入时,当输入了若干字符(不能包含换行符)之后,直接输入Ctrl+D,此时的Ctrl+D并不是文件结束符,而只是相当于换行符的功能,即结束当前的输入。以上面的代码段为例,如果执行时输入abc,然后Ctrl+D,程序输出结果为:
    abcabc

    注意:第一组abc为从终端输入的,然后输入Ctrl+D,就输出第二组abc,同时光标停在第二组字符的c后面,然后可以进行新一次的输入。这时如果再次输入Ctrl+D,则起到了文件结束符的作用,结束getchar()。
    如果输入abc之后,然后回车,输入换行符的话,则终端显示为:
    abc         //第一行,带回车
    abc         //第二行
                   //第三行

    其中第一行为终端输入,第二行为终端输出,光标停在了第三行处,等待新一次的终端输入。
    从这里也可以看出Ctrl+D和换行符分别作为行结束符时,输出的不同结果。
    EOF的作用也可以总结为:当终端有字符输入时,Ctrl+D产生的EOF相当于结束本行的输入,将引起getchar()新一轮的输入;当终端没有字符输入或者可以说当getchar()读取新的一次输入时,输入Ctrl+D,此时产生的EOF相当于文件结束符,程序将结束getchar()的执行。

    【补充】本文第二部分中关于EOF的总结部分,适用于终端驱动处于一次一行的模式下。也就是虽然getchar()和putchar()确实是按照每次一个字符 进行的。但是终端驱动处于一次一行的模式,它的输入只有到“/n”或者EOF时才结束,因此,终端上得到的输出也都是按行的。
    如果要实现终端在读一个字符就结束输入的话,下面的程序是一种实现的方法(参考《C专家编程》,略有改动)

    /*Edit by Godbach
      CU Blog: http://blog.chinaunix.net/u/33048/
    */

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

    int
    main(void)
    {
        int c;
        /* 终端驱动处于普通的一次一行模式 */
        system("stty raw");
       
       
    /* 现在的终端驱动处于一次一个字符模式 */
        c =getchar();
       
    putchar();
       
        /*
    终端驱动处又回到一次一行模式 */
         system("stty cooked");
       
        return 0;
    }

    编译运行该程序,则当如入一个字符时,直接出处一个字符,然后程序结束。
    由此可见,由于终端驱动的模式不同,造成了getchar()输入结束的条件不一样。普通模式下需要回车或者EOF,而在一次一个字符的模式下,则输入一个字符之后就结束了。


    (1) 字节的读取
    在正常的情况下, getc 以 unsigned char 的方式读取文件流, 扩张为一个整数,并返
    回. 换言之, getc 从文件流中取一个字节, 并加上24个零,成为一个小于256的整数,
    然后返回.

    int c;
    while ((c = fgetc (rfp))!= -1) // -1就是 EOF
    fputc (c, wfp);

    上面 fputc 中的 c 虽然是整数, 但在 fputc 将其写入文件流之前, 又把整数的高24位
    去掉了, 因此 fgetc, putc 配合能够实现文件复制. 到目前为止, 把 c 定义为
    char仍然是可行的, 但下面我们将看到,把 c 定义为 int 是为正确判段文件是否结束.

    (2) 判断文件结束.

    多数人认为文件中有一个EOF,用于表示文件的结尾. 但这个观点实际上是错误的,在文
    件所包含的数据中,并没有什么文件结束符. 对getc 而言, 如果不能从文件中读取,
    则返回一个整数 -1,这就是所谓的EOF. 返回 EOF 无非是出现了两种情况,一是文件已
    经读完; 二是文件读取出错,反正是读不下去了.

    请注意: 在正常读取的情况下, 返回的整数均小于256, 即0x0~0xFF. 而读不出返回的
    是 0xFFFFFFFF. 但, 假如你用fputc把 0xFFFFFFFF 往文件里头写, 高24位被屏蔽,写入的将
    是 0xFF. // lixforalpha 请注意这一点

    (3) 0xFF 会使我们混淆吗?

    不会, 前提是, 接收返回值的 c 要按原型定义为 int.

    如果下一个读取的字符将为 0xFF, 则

    int c;
    c = fgetc (rfp); // c = 0x000000FF;
    if (c != -1)    // 当然不等, -1 是 0xFFFFFFFF
    fputc (wfp);   // 噢, OXFF 复制成功.

    字符0xFF, 其本身并不是EOF.

    (4) 将 c 定义 char

    假定下一个读取的字符为 0xFF 则

    char c;
    c = fgetc (rfp); // fgetc(rfp)的值为 0x000000FF, 暗中降为字节, c = 0xFF
    if (c != -1)    // 字符与整数比较? c 被带符号(signed)扩展为0xFFFFFFFF, 喔噢,
    条件成立,文件复制提前退出.

    while ((c=fgetc(rfp))!=EOF) 中的判别条件成立, 文件复制结束! 意外中止.

    (5) 将 c 定义为 unsigned char;

    当读到文件末尾, 返回 EOF 也就是 -1 时,

    unsigned char c;
    c = fgetc (rfp); // fgetc (rfp)的值为EOF,即-1,即0xFFFFFFFF, 降格为字节, c=0xFF
    if ( c!= -1)  // c 被扩展为 0x000000FF, 永远不回等于 0xFFFFFFFF

    所以这次虽然能正确复制 0xFF, 但却不能判断文件结束. 事实上,在 c 为 uchar 时,
    c != -1 是永远成立的, 一个高质量的编译器, 比如 gcc会在编译时指出这一点.

    (6) 为何需要feof?
    FILE *fp;
    fp 指向一个很复杂的数据结构, feof 是通过这个结构中的标志来判断文件是否结束的.
    如果文件用 fgetc 读取, 刚好把最后一个字符读出时, fp 中的EOF标志不会打开,这时
    用feof判断,将会得到文件尚未结束的结论.

    fgetc 返回 -1 时, 我们仍无法确信文件已经结束, 因为可能是读取错误! 这时我们
    需要 feof 和 ferror.

    总结:EOF并不是存在于文件中的,而是一种状态,当读到文件末尾或者读取出错时就会返回这个值来判断文件结束。(即即使读取错误可能也被认为文件结束,所以就需要用feof 和 ferror来判断是不是真的文件结束了)

    当用getchar(c)时,即使c定义成字符型,也可以结束,主要是c与-1比较时,c也会从char转换为整型值。

    写个小程序验证了一下

    1. #include <stdio.h> 
    2. int main() 
    3.   char c; 
    4.   c = -1; 
    5.   printf("%x",c); 
    6.   return 0; 

    得到的结果为ffffffff,所以c即使定义为char型,读取文件等时还是能正常结束。


    关于EOF(文件结束符)问题的体会


    最近写了些代码,在对文件的操作中发现了很经典的EOF问题,呵呵。
    EOF,即end of file,文件结尾,作为文件结束的标志,在程序中常作为判断的一个标志。但在我们平常的程序中却常发生意想不到的结果。
    下面这段程序,猜猜它输出的是什么?
    char c;
    ifstream fin("d://dat");//设d:/dat文件已存在,内容为ab。
    while(!fin.eof())
    {
        fin >> c;
        cout << c;
    }
    输出结果是abb,没想到吗?你可能会问,再输出第一个b的时候,文件指针已经指向了EOF,为何不结束?
    问题的关键是文件EOF机制是怎样运作的。

    我们来谈三个问题:

    1、文件指针
    当打开一个文件时,文件指针位置为0,并不是指向第一个字符,即第一个字符的位置为1。这一点我们可以通过peek()函数验证。peek()返回的是当前文件指针下一个位置的字符。所以有:
    ofstream fo("d://dat");
    fo << 'h';
    fo.close();
    ifstream fi("d://dat");
    char temp = fi.peek();
    cout << temp;
    会显示h。
    还有,用fo.seekp(0,ios::beg),得文件指针为0;fo.seekp(0,ios::end),得文件指针指向最后一个字符。

    2、关于EOF
    很多朋友认为文件尾有EOF,这是错误的。EOF是流的状态标志。在 C++中,是在读取文件失败时才产生EOF。所以第一个程序中,在输出第一个b时,产生了EOF,再输出第二个b时读取到EOF,循环结束。

    3、解决EOF困惑的办法
    我感觉在判断文件结束上,最好的方法就是判断文件指针相对于开头的位置,是否等于文件长度。即:
    long filelen;
    ifstream fin("d://dat");//设d:/dat文件已存在,内容为ab。
    fin.seekg(0,ios::end);
    filelen = fin.tellg();//获取文件长度
    fin.seekg(0,ios::beg);
    while (1)
    {
        if (filelen == fin.tellg())//到达文件尾,即指向EOF
        {
            flag = true;
            break;
        }
        读取数据...
    }

    当然还有别的方法,就是用peek()的预读性。
    peek()返回当前文件指针下一个位置的字符,而指针位置不变。所以我们可以这样:
    while (fi.peel()!=EOF)
    {
        ...
    }
    当while循环体中,文件指针指向最后一个字符,若没有fi.peel()!=EOF,则需要再下一个循环中才能触发EOF。而加了fi.peel()!=EOF后,用预读的方法检测出了EOF。呵呵,这个方法挺好的吧!




    ifstream 流 判断文件是否结尾的函数eof()

    分类: C++ 1807人阅读 评论(2) 收藏 举报

     

       fstream流的eof()  判断有点不合常理

       按正常逻辑来说,如果到了文件末尾的话 ,那eof()应返回真

       但是,c++输入输出流如何知道是否到末尾呢?

       原来是根据的是: 如果fin>>不能再读入数据了,才发现到了文件结尾,这时才给流设定文件结尾的标志,此后调用eof()时,才返回真。

       假设

       fin>>x; //此时文件刚好读完最后一个数据(将其保存在x中)

       但是, 这时 fin.eof()仍未假 因为,fin流的标志eofbit是FALSE, fin流此时认为文件还没有到末尾

       只有当流再次读写时

       fin>>x; 发现已无可读写数据,此时流才知道到达了结尾,这时才将标志eofbit修改为TRUE

       此时流才知道了文件到底了末尾

       也就是说,eof在读取完最后一个数据后,仍是False,

                      当再次试图读一个数据时,由于发现没数据可读了 才知道到末尾了,此时才修改标志,eof变为TRUE

      以下例子:

    ifstream fin("D://line.txt");

    ofstream fout("D://T_line.txt",ios::trunc);


    list<tag_Point> test_list;

    tag_Point test;

    while (!fin.eof())
    {
     


      fin>>test.x;
      fin>>test.y;
      fin>>test.z;


      test_list.push_back(test);
     

    }

       fin.close();

     

    在运行时 发现  test_list中的数据比文本中的数据多一行,也就是 文本中最后一行的数据写了两遍

    始终无法理解

      现在明白了:》

      再读完最后一行后,

      因为fin.eof()仍为假, 所以会继续while循环

      当执行到while的第一个语句   fin>>test.x时,发现无可读数据了,此时修改流属性,fin.eof ()变为TRUE

      再执行   fin>>test.y; fin>>test.z;时,因为已经到文件末尾了 ,所以 test保留了上次的值,也即test中的值为变,还是文本最后一行

    的数据

      此时再push_back(test),压入列表的仍是最后一行数据

      由此导致了,列表中的数据比文本中的数据多一行

    ---------------------

    知道了原因 ,便很好作出修改了

      修改为:

    while (  fin>>test.x&&fin>>test.y&& fin>>test.z)
    {
     

      test_list.push_back(test);
     

    }

       fin.close();

    这样便没问题了 ,当读取完最后一行数据后,将其放入列表中,此时判断while条件,也就是再次读取数据,发现无数据可读,读取不成功 fin>>test.x返回False 由此结束循环。

    C++编程语言中的很多功能在我们的实际应用中起着非常大的作用。比如在对文件文本的操作上,就可以用多种方式来实现。在这里我们介绍的C++ eof()函数就是其中一个比较常用的基本函数。

    在使用C/C++读文件的时候,一定都使用过C++ eof()函数来判断文件是否为空或者是否读到文件结尾了,也会在使用这个函数的过程中遇到一些问题,如不能准确的判断是否为空或者是否到了文件尾,以至于有些人可能还会怀疑这个函数是不是本身在设计上就有问题。

    先来看看如下这段代码:

    1. #include < iostream>
    2. #include < fstream>
    3. using namespace std;
    4. int main()
    5. {
    6. char ch = 'x';
    7. ifstream fin("test.txt" /*, ios::binary*/);
    8. if (fin.eof())
    9. {
    10. cout < < "file is empty."< < endl;
    11. return 0;
    12. }
    13. while (!fin.eof())
    14. {
    15. fin.get(ch);
    16. cout < < ch;
    17. }
    18. system("pause");
    19. return 0;
    20. }
    21. 如果test.txt不存在,程序会形成死循环,fin.eof()永远返回false,就是说,eof在读取完最后一个数据后,仍是False,当再次试图读一个数据时,由于发现没数据可读了 才知道到末尾了,此时才修改标志,eof变为TRUE

      如果test.txt为空,程序打印出一个x字符,因为循环刚进来时eof()状态还没设置,当读不到数据时设置为ture循环结束;

      当test.txt中存在一字符串“abcd”且没有换行时,程序打印出“abcdd”,

      当存在以上字符串并且有一新的空行时,程序打印出“abcd”加上一空行。其实是两行 oA输出了两次,显示调试器的caret在第三行,为什么没OD了因为是以文本方式打开的 odoa自动转化为oa;

      这种现象可能让很多人很迷惑,程序运行的结果似乎很不稳定,时对时错。使用binary模式读时结果一样。在这里,大家可能有一个误区,认为eof()返回true时是读到文件的最后一个字符,其实不然,C++ eof()函数返回true时是读到文件结束符0xFF,而文件结束符是最后一个字符的下一个字符。

      while(infile.peek()!=EOF) 好处在于他获取的下一个数据(但并不会让FILE指针++哦)
    展开全文
  • !=EOF的含义和原理

    千次阅读 2017-10-23 22:23:38
    1.EOF是一个宏,许多函数(包括scanf)在读文件读到末尾时,会返回EOF。 2.OJ评判的原理: 输入:通过管道命令,将一个包含若干测试用例的文件作为【标准输入流】,所以需要while(scanf() != EOF)来判断测试文件是否...

    在ACM中经常遇见过这种情况,今天就来详细总结一下。(以while (scanf("%d", &a) != EOF)为例)

    1.EOF是一个宏,许多函数(包括scanf)在读文件读到末尾时,会返回EOF。

    2.OJ评判的原理:

    输入:通过管道命令,将一个包含若干测试用例的文件作为【标准输入流】,所以需要while(scanf() != EOF)来判断测试文件是否读完。

    输出:通过管道命令,将【标准输出流】,输出到一个文件中。

    3.评判:将程序的【输出文件】与【正确答案文件】进行比对:如果一样,则返回程序正确提示;否则,返回错误提示。

    4. 本机运行程序时,该语句的作用:

    当在本机运行程序,运行while(scanf() != EOF)时,程序会进入阻塞状态,即,

    运行到上面流程图中【temp = scanf("%d", &a)】这一句 时,程序会进入到阻塞状态——在这一语句处暂停。

    5.那么如何在本机输入的时候达到EOF的效果呢?

    Linux中,在新的一行的开头,按下Ctrl-D,就代表EOF;

    Windows中,Ctrl-Z表示EOF。

    6.等效语句:

    该语句用起来很方便,初学者却不太好理解,可以用以下语句来代替该语句。

    while(1)
    {
        if(scanf("%d",&a) != EOF)
            break;
    }
    展开全文
  • EOF的用法

    2018-02-08 17:27:15
    -EOF,两个都是获取stdin,并在EOF处结束stdin,输出stdout。 在我们使用cat &lt;&lt;EOF时,我们输入完成后,需要在一个新的一行输入EOF结束stdin的输入。EOF必须顶行写,前面不能用制表符或者空格。比如,...

    1、在命令行环境下,使用cat <<EOF 和 cat <<-EOF,两个都是获取stdin,并在EOF处结束stdin,输出stdout。

     在我们使用cat <<EOF时,我们输入完成后,需要在一个新的一行输入EOF结束stdin的输入。EOF必须顶行写,前面不能用制表符或者空格。比如,下面的语句就不会出错:

    例1:

    [plain] view plain copy
    1. <span style="font-size:18px;">cat <<EOF    
    2. Hello,world!    
    3. EOF</span>  

     如果结束分解符EOF前有制表符或者空格,则EOF不会被当做结束分界符,只会继续被当做stdin来输入。而<<-就是为了解决这一问题:

    例2:

    [plain] view plain copy
    1. cat <<-EOF    
    2. Hello,world!    
    3.       EOF     
     上面的写法,虽然最后的EOF前面有多个制表符和空格,但仍然会被当做结束分界符,表示stdin的结束。

    这就是<<和<<-的区别。


    2、在shell script中使用cat <<_EOF_ 和 cat <<-_EOF_ ,其区别和上述解释一样。

    例3:

    [plain] view plain copy
    1. <span style="font-size:18px;">#!/bin/bash  
    2. # Program to output a system information page  
    3. TITLE="System Information Report For $HOSTNAME"  
    4. CURRENT_TIME=$(date +"%x %r %Z")  
    5. TIME_STAMP="Generated $CURRENT_TIME, by $USER"  
    6. report_uptime () {  
    7.     cat <<-_HHH_  
    8.     <H2>System Uptime</H2>  
    9.     <PRE>$(uptime)</PRE>   
    10.     _HHH_  
    11.     return  
    12. }  
    13. report_disk_space () {  
    14.     cat <<-_EDD_  
    15.     <H2>Disk Space Utilization</H2>  
    16.     <PRE>$(df -h)</PRE>  
    17.     _EDD_  
    18.     return  
    19. }  
    20. #函数中的每行必须对齐,要空只能使用TAB键,否者脚本不能正确运行  
    21. report_home_space () {  
    22.     cat <<- _EOF_  
    23.     <H2>Home Space Utilization</H2>  
    24.     <PRE>$(du -sh /home/*)</PRE>  
    25.     _EOF_  
    26.     return  
    27. }  
    28. cat <<_EOF_  
    29. <HTML>  
    30.     <HEAD>  
    31.         <TITLE>$TITLE</TITLE>  
    32.     </HEAD>  
    33.     <BODY>  
    34.         <H1>$TITLE</H1>  
    35.         <P>$TIME_STAMP</P>  
    36.         $(report_uptime)  
    37.         $(report_disk_space)  
    38.         $(report_home_space)  
    39.     </BODY>  
    40. </HTML>  
    41. _EOF_  
    42. </span>  


    3、字符并不是只能用EOF也可以其它的,像例3这样。

    展开全文
  • C语言中,怎么用EOF结束输入

    万次阅读 多人点赞 2018-07-15 22:06:25
    EOF 是个宏,其意思是:End Of File,文件尾标志。 从数值上来看,就是整数-1在C语言的头文件中对其进行了宏定义:1libio.h: # define EOF (-1)当读文件操作时,遇到文件结束位置或读数据出错均会返回 EOF。 ...
  • EOF详解

    千次阅读 2014-09-10 20:03:40
    缩写通常为EOF(End Of File)
  • linux shell脚本EOF妙用

    万次阅读 多人点赞 2017-05-11 20:36:25
    在平时的运维工作中,我们经常会碰到这样一个场景: ...这个时候,就可以使用EOF结合cat命令进行行内容的追加了。 下面就对EOF的用法进行梳理: EOF是END Of File的缩写,表示自定义终止符.既然自定义,那么EOF就不
  • C语言中EOF什么意思

    万次阅读 2019-03-06 20:26:47
    在while循环中以EOF作为文件结束标志,这种以EOF作为文件结束标志的文件,必须是文本文件。在文本文件中,数据都是以字符的ASCII代码值的形式存放。我们知道,ASCII代码值的范围是0~127,不可能出现-1,因此可以用...
  • C语言中EOF是什么意思?

    千次阅读 多人点赞 2017-07-19 08:05:09
    C语言中EOF是什么意思?
  • EOF是什么?

    2014-03-13 16:33:00
    我学习C语言的时候,遇到的一个问题就是EOF。 它是end of file的缩写,表示"文字流"(stream)的结尾。这里的"文字流",可以是文件(file),也可以是标准输入(stdin)。 比如,下面这段代码就表示,如果不是...
  • 解决springboot 文件上传 java.io.EOFException: Unexpected EOF read on the socket问题 问题原因,上传文件还没到末尾就被客户端中断,是超出tomcat文件连接时间了,就被跳转。 解决方案 在application.yml配置...
  • cat <<EOF与cat <<-EOF的区别

    万次阅读 2015-05-05 22:02:43
    cat <<-EOF和cat <<EOF 你知道有什么区别吗?
  • 解决方案 因为logcat日志信息太多了了, 解决,在终端或命令窗口 adb logcat -G 2m
  • Python错误SyntaxError: unexpected EOF while parsing

    万次阅读 多人点赞 2016-09-29 08:38:52
    这个错误是你语法有问题,我当时碰到是因为print(d.drop()// 少打了一个括号,别盲目的相信自动补全 ,自己认真检查一下,肯定这行代码少了或者多了东西,希望有用。
  • Unexpected EOF read on the socket问题解决

    万次阅读 2018-10-26 15:31:24
    文件上传报错java.io.EOFException: Unexpected EOF read on the socket 问题解决 问题原因 看字面意思,说是文件还没到末尾就被客户端中断,可是文件已经被上传到了服务器,并且信息也已经返回,为什么会这样?猜想...
  • Python EOF 的错误

    万次阅读 2017-03-11 19:37:42
    Python 的一个错误E902: TokenError: EOF in multi-line statement还有其他类似 EOF 的,是不是括号或引号不匹配。
  • Premature EOF: no length prefix available

    万次阅读 2014-03-14 16:26:45
    2013-05-02 14:02:41,063 INFO org.apache.hadoop.hdfs.DFSClient: Exception in createBlockOutputStream java.io.EOFException: Premature EOF: no length prefix available Solution: 由于DataNode终止了blo
  • shell中的EOF用法

    万次阅读 多人点赞 2015-01-13 14:43:37
    1、EOF   Shell中通常将EOF与   可以把EOF替换成其他东西,意思是把内容当作标准输入传给程序。  回顾一下字符串。 例子:自动登录mysql(root:root,passwd:123456),查询test库,test1表里的user=aa的记录。 ...
  • java.io.IOException: File /user/ashsshar/olhcache/loaderMap9b663bd9 could only be replicated to 0 nodes instead of minReplication (=1). There are 3 datanode(s) running and 3 node(s) are excluded in
  • Linux脚本中用户自定义终止符-EOF

    万次阅读 2013-09-14 10:40:26
    Linux脚本中用户自定义终止符-EOF的思考
1 2 3 4 5 ... 20
收藏数 453,983
精华内容 181,593
关键字:

eof