精华内容
下载资源
问答
  • EOF用法

    千次阅读 2012-07-20 10:21:05
    >> 关于文件结束符EOF EOF 是 End Of File 的缩写。 在 C 语言中,它是在标准库中定义的一个宏。 人们经常误认为 EOF 是从文件中读取的一个字符。其实,EOF 不是一个字符,它被定义为是 int 类型的...
     >> 关于文件结束符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 返回EOF如果读到文件末
    大师级经典的著作,要字斟句酌的去读,去理解。以前在看K&R的The C Programming Language(SecondEdition)
    第1.5节的字符输入/输出,被getchar()和EOF所迷惑了。可能主要还是由于没有搞清楚getchar()的工作原理和EOF的用法。因此,感觉很有必要总结一下,不然,很多琐碎的知识点长时间过后就会淡忘的,只有写下来才是最好的方法。


    其实,getchar()最典型的程序也就几行代码而已。本人所用的环境是DebianGNU/Linux,在其他系统下也一样。
    一、getchar的两点总结:
    1.getchar是以行为单位进行存取的。
    当用getchar进行输入时,如果输入的第一个字符为有效字符(即输入是文件结束符EOF,Windows下为组合键Ctrl+Z,Unix/Linux下为组合键Ctrl+D),那么只有当最后一个输入字符为换行符'\n'(也可以是文件结束符EOF,EOF将在后面讨论)时,getchar才会停止执行,整个程序将会往下执行。譬如下面程序段:
    while((=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;
    =getchar();


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

    /* 现在的终端驱动处于一次一个字符模式 */
    =getchar();
    putchar();

    /* 
    终端驱动处又回到一次一行模式 */
        system("stty cooked");

    return 0;
    }

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

    希望本文可以对初学C的朋友提供一点帮助,也希望能和其他朋友进行交流。其中理解不对的地方若能得到指正和建议,本人将不胜感激。同时,本文参考了chinaunix.net关于getchar讨论的帖子和一位博友的文章,链接地址分别为:
    http://blog.chinaunix.net/u/9861/showart_64652.html
    http://bbs.chinaunix.net/viewthread.php?tid=679688&extra=&page=1
    欢迎交流和指正。

    在另一个贴子中,我与一些朋友对 getc 展开了一些讨论. 由于觉得楼主最终未能明白
    我的意思,所以我把我个人的看法总结出来,写在这里.我不太擅长说明,但已经尽力了. 
    任何人转本贴, 请务必把本人的名字写在显眼的位置.  


    约定编译器为 gcc2/x86: 
    所以 char, unsigned char 为 8 位, int 为 32 位

    请参考 http://bbs.chinaunix.net/forum/23/20031223/229236.html


    (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.

    展开全文
  • 1. 输入到EOF(-1)停止 如果一般自己调试程序,在输入数据未知数据数量的时候,希望随时可以停止数据输入。一般情况下,两种写法,一种遇换行符’\n’停止,但是由于’\n’符在输入阶段表示开始获取值的开始信号,...

    1. 输入到EOF(-1)停止

      如果一般自己调试程序,在输入数据未知数据数量的时候,希望随时可以停止数据输入。一般情况下,两种写法,一种遇换行符’\n’停止,但是由于’\n’符在输入阶段表示开始获取值的开始信号,如果不适用getchar()获取,一般scanf默认是不会认为换行是输入的数据,所以写法稍微复杂。该写法不做今天重点内容,如果想要学习该机制程序写法,详细请看下面的博文: 

    http://blog.csdn.net/fx677588/article/details/52712417 C/C++ 输入一行每隔一个空格一个数据

      另一种写法则是模拟读取文件,遇文件结尾符停止读取。这个是我们今天想要研究的问题,下面我们先看对应程序的写法:

    int data;
    while(scanf("%d",&data)!=EOF) //EOF即文件结尾符,-1
    {
        printf("%d",data);
    }

      或者

    while(scanf("%d",&data)!=-1)//EOF即-1

      scanf()正常输入,返回成功读取的数据个数。当读取到文件结尾返回的是EOF,即-1。那么问题又来了,如何键盘输入文件结束符呢?

    2. 键盘输入文件结尾符

      键盘输入是可以用来模拟文件结尾符,查相关资料你会知道,windows下可通过按“Ctrl +Z”、linux下可通过“Ctrl + D”来达到输入文件结束符的效果(提示:输入’Z’和’D’不用区分大小写)。
      但是输入时候会发现,为什么得不到理想的效果呢?实际上多数介绍忽略了操作上的细节。以windows上为例,实际操作过程是“换行Enter”,然后“Ctrl+Z”,然后再“换行Enter”才能终止上面的,linux上操作过程一样,“Ctrl+Z”换位“Ctrl+D”。
      直接“Ctrl+Z”不换行是不能成功读取到文件结尾符的。

    int data;
    while(scanf("%d",&data)!=EOF) //EOF即文件结尾符,-1
    {
        printf("%d",data);
    }

      对应终端上显示和操作如下显示,^Z即对应“Ctrl+Z”操作地方:


    这里写图片描述


    个人学习记录,由于能力和时间有限,如果有错误望读者纠正,谢谢!

    转载请注明出处:CSDN 无鞋童鞋。

    展开全文
  • linux下EOF自定义终止符

    千次阅读 2017-07-13 21:25:07
    在平时的运维工作中,我们经常会碰到这样一个场景: ...这个时候,就可以使用EOF结合cat命令进行行内容的追加了。 下面就对EOF的用法进行梳理: EOF是END Of File的缩写,表示自定义终止符.既然自定义,那么EOF就不是固

    在平时的运维工作中,我们经常会碰到这样一个场景:
    执行脚本的时候,需要往一个文件里自动输入N行内容。如果是少数的几行内容,还可以用echo追加方式,但如果是很多行,那么单纯用echo追加的方式就显得愚蠢之极了!
    这个时候,就可以使用EOF结合cat命令进行行内容的追加了

     在shell编程中,”EOF“通常与”<<“结合使用,“<<EOF“表示后续的输入作为子命令或子shell的输入,直到遇到”EOF“,再次返回到主调shell,可将其理解为分界符(delimiter)。既然是分界符,那么形式自然不是固定的,这里可以将”EOF“可以进行自定义,但是前后的”EOF“必须成对出现且不能和shell命令冲突。其使用形式如下:
    交互式程序(命令)<<EOF
    command1
    command2
    ...
    EOF
           ”EOF“中间的内容将以标准输入的形式输入到”交互式程序“,当shell看到”<<“知道其后面输入的分界符,当shell再次看到分界符时,两个分界符中间的部分将作为标准输入。
           "EOF"一般常和cat命令连用。
    注意,最后的”EOF“必须单独占一行。
    需要注意的是,第一个EOF必须以重定向字符<<开始,第二个EOF必须顶格写,否则会报错

    下面就对EOF的用法进行梳理:
    EOF是END Of File的缩写,表示自定义终止符.既然自定义,那么EOF就不是固定的,可以随意设置别名,在linux按ctrl-d就代表EOF.
    EOF一般会配合cat能够多行文本输出.
    其用法如下:
    <<EOF        //开始
    ....
    EOF            //结束

    还可以自定义,比如自定义:
    <<BBB        //开始
    ....
    BBB              //结束

    通过cat配合重定向能够生成文件并追加操作,在它之前先熟悉几个特殊符号:
    < :输入重定向
    > :输出重定向
    >> :输出重定向,进行追加,不会覆盖之前内容
    << :标准输入来自命令行的一对分隔号的中间内容.

    下面通过具体实例来感受下EOF用法的妙处:
    1)向文件test.sh里输入内容。
    [root@slave-server opt]# cat << EOF >test.sh 
    > 123123123
    > 3452354345
    > asdfasdfs
    EOF
    [root@slave-server opt]# cat test.sh 
    123123123
    3452354345
    asdfasdfs

    追加内容
    [root@slave-server opt]# cat << EOF >>test.sh 
    > 7777
    > 8888
    EOF
    [root@slave-server opt]# cat test.sh 
    123123123
    3452354345
    asdfasdfs
    7777
    8888

    覆盖
    [root@slave-server opt]# cat << EOF >test.sh
    > 55555
    EOF
    [root@slave-server opt]# cat test.sh 
    55555

    2)自定义EOF,比如自定义为wang
    [root@slave-server opt]# cat << wang > haha.txt
    > ggggggg
    > 4444444
    > 6666666
    wang
    [root@slave-server opt]# cat haha.txt 
    ggggggg
    4444444
    6666666

    3)可以编写脚本,向一个文件输入多行内容
    [root@slave-server opt]# touch /usr/local/mysql/my.cnf               //文件不提前创建也行,如果不存在,EOF命令中也会自动创建
    [root@slave-server opt]# vim test.sh
    #!/bin/bash

    cat > /usr/local/mysql/my.cnf << EOF                                      //或者cat << EOF > /usr/local/mysql/my.cnf
    [client]
    port = 3306
    socket = /usr/local/mysql/var/mysql.sock

    [mysqld]
    port = 3306
    socket = /usr/local/mysql/var/mysql.sock

    basedir = /usr/local/mysql/
    datadir = /data/mysql/data
    pid-file = /data/mysql/data/mysql.pid
    user = mysql
    bind-address = 0.0.0.0
    server-id = 1
    sync_binlog=1
    log_bin = mysql-bin

    [myisamchk]
    key_buffer_size = 8M
    sort_buffer_size = 8M
    read_buffer = 4M
    write_buffer = 4M

    sql_mode=NO_ENGINE_SUBSTITUTION,STRICT_TRANS_TABLES 
    port = 3306
    EOF

    [root@slave-server opt]# sh test.sh           //执行上面脚本
    [root@slave-server opt]# cat /usr/local/mysql/my.cnf    //检查脚本中的EOF是否写入成功
    [client]
    port = 3306
    socket = /usr/local/mysql/var/mysql.sock

    [mysqld]
    port = 3306
    socket = /usr/local/mysql/var/mysql.sock

    basedir = /usr/local/mysql/
    datadir = /data/mysql/data
    pid-file = /data/mysql/data/mysql.pid
    user = mysql
    bind-address = 0.0.0.0
    server-id = 1
    sync_binlog=1
    log_bin = mysql-bin

    [myisamchk]
    key_buffer_size = 8M
    sort_buffer_size = 8M
    read_buffer = 4M
    write_buffer = 4M

    sql_mode=NO_ENGINE_SUBSTITUTION,STRICT_TRANS_TABLES 
    port = 3306

    ---------------------------------------------------------------------------------
    下面分享一个自动新建分区并挂载的脚本:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    [root@es-node1 ~] # cat auto_add_disk.sh         
    #!/bin/bash
    fdisk  /dev/sdb  <<EOF
    n
    p
    1
     
     
    wq
    EOF
     
    /sbin/mkfs .ext4  /dev/sdb1  &&   /bin/mkdir  -p  /data  &&  /bin/mount  /dev/sdb1  /data
    echo  'LABEL=data_disk /data ext4 defaults 0 2'  >>  /etc/fstab


    我们经常在shell脚本程序中用<<EOF重定向输入,将我们输入的命令字符串作为一个执行程序的输入,这样,我们就不需要在那个程序环境中手工输入命令,以便自动执行我们需要的功能,例如:

    [plain]  view plain  copy
    1. sqlplus emssxjk/emssxjk <<EOF  
    2. select count(*) from sncn_yxyj where create_date like sysdate;  
    3. EOF  


    其中的SQL语句相当于在sqlplus程序环境中输入的,这样输入的内容夹在两个EOF之间,可长可短,EOF也可以换成其他任意的字符,大小写不论,只要成对出现即可,例如:

    [plain]  view plain  copy
    1. sqlplus emssxjk/emssxjk <<STD  
    2. select count(*) from sncn_yxyj where create_date like sysdate;  
    3. STD  

    当然这个 标志性字符不能用保留字,最常用的还是EOF。

    需要注意的是,第一个EOF必须以重定向字符<<开始,第二个EOF必须顶格写,否则会报错。

    再看一个自动FTP的例子:

    [plain]  view plain  copy
    1. #ftp data to 10.178.37.244  
    2. rq=`date +%Y%m%d`  
    3. cd /data/product/song  
    4. ftp -i -n <<!  
    5. open 10.178.37.244   
    6. user oracle post   
    7. cd ems   
    8. bin  
    9. put ${rq}.dat   
    10. bye  
    11. !  




    ***************当你发现自己的才华撑不起野心时,就请安静下来学习吧***************
    展开全文
  • 假如给你一个最大长度为10000的整型数组,现在通过键盘依次输入数组的值,中间以至少一个空格间隔,最简单的表达方法之一: ...=EOF); for(j=0;j<i;j++) printf("%d ",nums[j]); return 0; } ...

    假如给你一个最大长度为10000的整型数组,现在通过键盘依次输入数组的值,中间以至少一个空格间隔,最简单的表达方法之一:

    #include<stdio.h>
    int main()
    {
    	int nums[10000]={0},i=0,j;
    	while(scanf("%d",&nums[i++])!=EOF);
    	for(j=0;j<i;j++)
    		printf("%d ",nums[j]);
    	return 0;
    }
    

    方法之二:

    #include<stdio.h>
    int main()
    {
        int nums[10000]={0},i=0,j;
        do{
            scanf("%d",&nums[i++]);
        }while(getchar()!='\n');
        for(j=0;j<i;j++)
            printf("%d ",nums[j]);
        return 0;
    }
    

    方法之三:

    #include<stdio.h>
    int main()
    {
        int i,j,a[10000]={0};
        char c='0';
        for(i=0;i<10000&&c!='\n';i++)
        {
            scanf("%d",&a[i]);
            c=getchar();
        }
        //次方法只适用于结尾时直接换行的情况,\
        如果在换行之前输入了空格则不会结束输入      
        for(j=0;j<i;j++)
            printf("%d ",a[j]);
        return 0;
    }
    

    输入示例:1 2 3 4 5 7 9 2 3 3
    输出示例:1 2 3 4 5 7 9 2 3 3

    展开全文
  • = EOF)是没办法判断一行数据输入完成的,我还为此很纠结。cin 和scanf的输入我自己试了之后一直没解决这个问题。之后在博主:  吃苹果阿 里面看到一道题目的做法,瞬间感觉到好像问题解决了。对于一组测试...
  • gets与换行再认识

    2020-04-21 21:30:57
    需要接收gets后的换行吗?
  • EOF问题,如何结束输入流输入

    千次阅读 2013-07-03 15:46:11
    把输入字符输出越到的问题, while((c=getchar())!=EOF) putchar(); 回车无法结束循环,原因是回车不是流结束符,在输入流中流结束标志是 Ctrl+Z 或者 Ctrl+D 键 另外如果有输入再输入 Ctrl+Z 或者 ...
  • 这行代码的意思是,检测到输入的字符为换行符,破坏循环(即结束循环)。   ③break是退出当前循环(注意,if这一行语句不是循环)。即结束while这一个循环。但不结束所有循环。 且break语句后面的...
  • 文件结束符EOF

    2019-09-19 04:03:41
    关于文件结束符EOF EOF 是 End Of File 的缩写。 在C语言中,它是在标准库中定义的一个宏。 人们经常误认为EOF 是从文件中读取的一个字符(牢记)。其实,EOF 不是一个字符,它被定义为是 int 类型的一个负数...
  • 由于字符的ASCII码不可能出现 -1, 因此EOF定义为 -1 是合适的以文本形式读取文件内容, 读入的字符值等于EOF时, 表示读入的已不是正常的字符而是文件结束符以二进制形式读取文件内容, 信息都是以数值方式存在的, ...
  • while (cin >> px >> py >> qx >> qy) //cin 输入是类型安全的,不会把一个字母当作数字读进来, //你输入错误或者达到EOF时,bool(cin)就是false了,所以循环退出 { // 这里的int类型丢失了精度,是你错误的...
  • 我正在编写一个程序,该程序直接从用户输入中读取数据,并且想知道如何(无循环)从标准输入中读取所有数据,直到EOF。 我正在考虑使用cin.get( input, '\0' ),但'\0'并不是真正的EOF字符,它只会读取到EOF或'\0',以...
  • gets与scanf与EOF

    2021-03-02 21:42:55
    1.从stdin流中读取字符串,直至接受到换行符或EOF时停止,并将读取的结果存放在buffer指针所指向的字符数组中。换行符不作为读取串的内容,读取的换行符被转换为‘\0’空字符,并由此来结束字符串。 2. 返回值,...
  • EOF

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

    千次阅读 2016-01-27 13:40:39
    最近写了些代码,在对文件的操作中发现了很经典的EOF问题,呵呵。 EOF,即end of file,文件结尾,作为文件结束的标志,在程序中常作为判断的一个标志。但在我们平常的程序中却常发生意想不到的结果。 ...
  • 回车 换行 字符串读取

    千次阅读 2020-08-09 15:45:40
    ①回车与换行 在Windows中: ‘\r’ 回车,回到当前行的行首,而不会换到下一行,如果接着输出的话,本行以前的内容会被逐一覆盖;’\n’ 换行,换到当前位置的下一行,而不会回到行首; Unix系统里,每行结尾只有...
  • if ((fp=fopen(filename,"rt"))==NULL) { printf("文件不存在!!!\n\n"); } ch1=fgetc(fp); while (ch1!=EOF) //处理文件流,判断文件内容... 换行之后的中文没提取到(好像是只认了换行符,就停止读取了) 能解决吗
  • 貌似是eof为真,导致读文件结束了 这是怎么回事啊? void readCodeFile() { ifstream inf; ofstream outf; int w[200], c = 0; char s[200]; string code; HuffTree<char> *TreeArray[100]; HuffNode* ...
  • string fgets ( int $handle...碰到换行符(包括在返回值中)、EOF 或者已经读取了 length - 1 字节后停止(看先碰到那一种情况)。如果没有指定 length,则默认为 1K,或者说 1024 字节。实际使用中:fgets()经常和whil...
  • 关于EOF和Ctrl+Z~

    2017-03-28 17:25:52
    #include #include #include int main(void) { int ch;//可以留意一下为什么这里用int型的变量哦 while ((ch = getchar()) != EOF) { putchar(ch); } system("pause"); return 0; }
  • getchar,putchar,EOF

    2020-09-20 17:15:12
    本文将以简单的代码介绍getchar(), putchar() 和 EOF 。 定义 getchar() “getchar() reads the next input character from a text stream and returns that as its value” “the characters normally come from...
  • EOF小结

    2012-08-12 19:46:11
    大师级经典的著作,要字斟句酌的去读,去理解。... 看到1.5节的字符输入/输出,再次的被getchar()和EOF所迷惑了。可能主要还是由于没有搞清楚getchar()的工作原理和EOF的用法。因此,感觉很有必要总结一下,
  • '\0','\n',EOF的区别

    千次阅读 2017-11-11 16:58:07
    但是,你写一个小程序,并以EOF作为判断条件,就无法输入文档的结尾了,只能人工输入一个,这个人工输入的文档结尾就是Ctrl+Z.(Ctrl+Z的值是-1,可以尝试将EOF替换成-1) 6.示例: while(scanf(“%d”,&n)!=EOF)...
  • 你可以从stdin读取可变数量的数据的唯一方法是使用循环。 我总是发现std::getline()函数工作得很好:std::string line;... }默认情况下getline()读取直到换行。 你可以指定一个替代的终止字符,但是EO...
  • 关于文件结束符EOF EOF 是 End Of File 的缩写。 在C语言中,它是在标准库中定义的一个宏。 人们经常误认为EOF 是从文件中读取的一个字符(牢记)。其实,EOF 不是一个字符,它被定义为是 int 类型的一个负数...
  • 在终端输入字符并非输入一个字符就会返回,而是在遇到回车换行前,所有输入的字符都会缓冲在键盘缓冲器中,直到回车换行一次性将所有字符按序依次赋给相应的变量,在这里一定要注意最后一个字符即

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,405
精华内容 2,562
关键字:

eof当换行时停止