C 未检测到 EOF-6ren

C 未检测到 EOF

转载作者：行者123 更新时间：2023-11-30 17:54:53

我正在编写一个程序，该程序一次读取输入一个字符，并确定它是十进制、八进制还是十六进制，然后将其转换为十进制输出。该部分有效，问题是我使用 while((ch=getchar()) != EOF) 来浏览文本，但 while 循环永远不会终止。我听说EOF相当于-1，使用EOF的方法是control+z来结束程序，但我希望它是自动的。我一直在使用标准输入并为其提供 .txt 文本，这两种方式程序都不会终止。我想知道是否有人可以看一下我的代码并看看我哪里出了问题。

(很长，抱歉，我只是不知道这是否是我在案例中所做的事情)

int main (void) 
{
    int ch, chVal, decVal ;

    ch=getchar() ;

    while ((ch != EOF)) 
    {
        switch ( ch ) 
        {
            case ' ' :
                /* Just read until it’s not a space */
                while( ( ch == SPACE ) || ( ch== EOL ) ) 
                        ch=getchar();


            case '0' :
                /* integer, octal or hex possibilities */
                ch=getchar() ;

                /**** HEX ****/

                if ( ( ch=='x' ) || ( ch=='X' ) ) 
                {
                    /* potential hex. So far we have read in 0x.  We need to see what's next. */                
                    ch=getchar() ;

                    if ( ch== SPACE ) 
                    {
                        /* all we had was 0x entered */
                        outputIllegalToken() ;
                        break ; /* we need to end every pass through the switch with a space char (space, eoln or eof) */
                    }

                    decVal=0 ;
                    while ( ( ( '0' <= ch ) && ( ch <= '9' ) ) || ( ( 'a' <= ch ) && ( ch <= 'f' ) ) || ( 'A' <= ch ) && ( ch <= 'F' ) ) 
                    {
                        chVal = DecToHex( ch ) ;
                        decVal*=16 ;
                        decVal+=chVal ;
                        ch=getchar() ;
                    }

                    /* ch is no longer a hex val. */
                    if ( ch == SPACE || ch == EOL || ch == EOF ) 
                    {
                        /* All is good. */
                        outputHex( decVal );
                    } 
                    else 
                    {
                        if ( ch=='l' || ch=='L' ) 
                        {
                            ch=getchar() ;
                            if (( ch== SPACE ) || ( ch== EOL ) || ( ch==EOF )) 
                            {
                                outputLongHex( decVal ) ;
                            } 
                            else 
                            {
                                outputIllegalToken() ;
                                while ( ch!= SPACE && ch!= EOL && ch!= EOF ) 
                                { 
                                        getchar();
                                }
                            }
                        } 
                        else 
                        {
                            outputIllegalToken() ;
                            ch = getchar() ;
                            while ( ( ch!= SPACE ) && ( ch!= EOL ) && ( ch!= EOF ) ) 
                            { 
                                ch=getchar(); 
                            }
                        }
                    }
                    printf("do we come here? \n");
                    count++;
                     break;
                    /* end of the 0x scenario  ch is  a space char */
                }

               /****** 0 *******/

                if ( ch==' ' ) 
                {
                    /* just a 0 */
                    outputDecimal(0);
                    count++;
                    break ; /* end of 0 alone scenario. ch is a space */
                }

                /***** 0L ******/

                if ( ch=='l' || ch=='L' ) {
                    /* if there is space after the l, it's ok. otherwise illegal. */
                    ch=getchar() ;
                    if ( ( ch== SPACE ) || ( ch== EOL ) || (ch==EOF ) ) 
                    {
                        outputLongDecimal(0);
                    } 
                    else 
                    {
                        outputIllegalToken() ;
                        /* read to the next space */
                        ch=getchar() ;
                        while ( ( ch!= SPACE ) && ( ch!= EOL ) & ( ch!=EOF ) ) 
                                { 
                                ch=getchar(); 
                                }
                    }
                    count++;
                    break ;  /* end of 0L scenario.  ch is a space char. */
                }

                /**** Octal ****/

                if ( ( '0'<=ch )&&( ch<='7' ) ) 
                {
                    /* potentially octal  */
                    chVal=DecToHex( ch ) ;
                    decVal=chVal ;
                    ch=getchar() ;
                    while ( ( '0'<=ch )&&( ch<='7' ) ) 
                    {
                        decVal*=8 ;
                        decVal+=DecToHex( ch ) ;
                        ch=getchar() ;
                    }
                    /* no longer octal ch */
                    if ( ch== SPACE || ch== EOL || ch==EOF ) 
                    {
                        outputOctal( decVal ) ;

                    } 
                   else 
                    {
                        if ( ch=='l' || ch=='L' ) 
                        {
                            ch=getchar() ;
                            if (( ch== SPACE ) || ( ch== EOL ) || ( ch==EOF )) 
                            {
                                outputLongOctal(decVal) ;
                            } 
                            else 
                            {
                                outputIllegalToken() ;
                                while ( ch!= SPACE && ch!= EOL && ch!=EOF ) 
                                { 
                                        getchar();
                                }
                            }
                        } 
                        else 
                        {
                            outputIllegalToken() ;
                            ch = getchar() ;
                            while ( ( ch!= SPACE ) && ( ch!= EOL ) && ( ch!=EOF ) ) 
                            { 
                                ch=getchar(); 
                            }
                        }
                    count++;
                    break;/* end octal scenario  ch is a space character. */
                }

                count++;
                break ;

            case '1':
            case '2':
            case '3':
            case '4':
            case '5':
            case '6':
            case '7':
            case '8':
            case '9':
                /* potential decimal input */

                chVal=DecToHex( ch ) ;  /* convert the character to a number */
                decVal=chVal ;          /* keep track of the overall number */

                ch=getchar() ;
                while ( ( '0'<=ch ) && ( ch<='9' ) ) 
                {
                    chVal=DecToHex( ch ) ;
                    decVal*=10 ;
                    decVal+=chVal ;
                    ch=getchar() ;
                }

                /* integers have ended.  spaces or l is acceptable. everything else is illegal */
                if ( ( ch== SPACE ) || ( ch== EOL ) || ( ch==EOF )) 
                {
                    outputDecimal( decVal ) ;
                } 
                else if ( ( ch=='l' ) || ( ch=='L' ) ) 
                {
                    /* next char needs to be space in order to be a valid long integer */
                    ch==getchar() ;
                    if ( ( ch== SPACE ) || ( ch== EOL ) || ( ch==EOF ) ) 
                    {
                        outputLongDecimal( decVal ) ;
                    } 
                    else 
                    {
                        outputIllegalToken() ;
                        while ( ( ch!= SPACE) && ( ch!= EOL ) && ( ch!=EOF ) ) 
                        {
                            ch=getchar();
                        }
                    }
                }
                count++;
                break;
        }
    }
}

return 0;
}

最佳答案

这个:

            while( ( ch == SPACE ) || ( ch== EOL ) ) 
                    ch=getchar();

如果输入中的最后一个字符是空格，

将导致无限循环。我认为您的意思只是 ( ch == SPACE )，但仅用 break; 替换整个语句也可以。

可能还有其他错误...

关于C 未检测到 EOF，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/14692383/

文章推荐：在 pthread 中计算 pi

文章推荐： c# - 无法从 C# 中看到托管 C++ DLL 中的公共(public)结构

文章推荐： c# - 使用 Linq 表达式在通用存储库中实现搜索

文章推荐： c - Ubuntu 11.04 中的信号处理功能

eof - 如何区分 EOF 字符和文件的实际结尾？
读取文件时，我知道提供的最后一个字符是 EOF。现在，当我有 EOF 时会发生什么？该文件中的字符？如何区分文件的“真实”结尾和 EOF特点？最佳答案我决定将我的评论移至答案。您的文件中不能有
Bash - <
GNU Bash - 3.6.6 Here Documents [n]<<[-]word here-document delimiter If any part of word is

eof - fgetc() 不会在 EOF 中停止
试图查看论坛但无法重新访问。我正在尝试阅读文本。文字是:“给 b” 但是在使用 fgetc() 时，没有达到 EOF，最后我得到 '\n'，然后是无穷大的 'y' 样本。这是我的代码: Node*
c - EOF 在...EOF 之前到达
我正在做一个非常简单的作业，需要输出文件的内容，但在做任何事情之前我意外地到达了 EOF。该文件仅包含单词“pig”，并且由于某种原因 EOF 返回 16。我正在使用 Dev-Cpp 并且该程序是用
eof - kubectl 应用/创建 "unexcpected EOF"
我的 kubectl 无法读取文件，每次都返回 'error: unexpected EOF'。 kubectl apply -f service.yaml > error: unexpected E
zsh - 为什么不使用 <
我想知道什么时候使用 cat Hello world! () { setopt localoptions shnullcmd test-nullcmd } # nothing will be

c++ - 期待 eof 但 eof 附近的任意数据
我试图找出我正在向其中写入特定数据的文件中不需要的尾随结束数据的原因，并且不相信我在写入文件时出错。输出如下: building room_numbr capacity packard
c++ - 使用 setw : to eof or not to eof? 读取
考虑下面的简单例子 #include #include #include using namespace std; int main() { string str = "string";
c++ - Visual Studio 中 EOF 之前的 EOF
我在一个程序中有这个片段(在 Visual Studio 2005 中): if(_eof(fp->_file)) { break; } 当达到 eof 时，它打破了封闭循环。但是程序无法解析
types - 在 Typed Racket 中表示函数 EOF -> False, A -> A ∀ A ≠ EOF？
我正在尝试为 Typed Racket 中的以下函数定义类型注释: (define (neof x) (if (eof-object? x) #f x)) 不加注释给出了类型: (Any ->
shell - shell heredocs 中的
我正在为 Linux 构建系统的模块编写 .spec 文件，遇到一个小问题并想分享它。用于编写脚本文件: cat /path/to/somewhere/script #blah blah EOF

c++ - fscanf : is error or EOF possible without EOF returned?
我有一个 C++ 程序，它从一个文件中读取我希望有一堆格式相同的记录。如果遇到意外情况，无论是记录格式不正确还是输入失败，我都想停止阅读，我想区分这些不同的情况。我看过 this answer并查看
bash - shell 中的 <
我注意到它们之间的几个区别: 在 <

python-2.7 - pexpect.EOF : End Of File (EOF). 异常样式平台
预期我正在生成子进程并执行“ssh”远程框。从最近几天开始它工作正常，现在突然间，每当我尝试生成子进程时，它都会抛出错误。不确定发生了什么。直到现在我一直在使用 pexpect 3.1，我遇到了这个
c - 当遇到 EOF 字符时，使用 getchar() 从控制台读取字符直到遇到 EOF 字符的循环不会退出
这个问题已经有答案了: Why two EOF needed as input? [duplicate] (2 个回答) Why do I require multiple EOF (CTRL+Z)
c++ - 使用 while(!infile.eof()) 好奇如何在 C++ 中的 eof() 之前打破它
我正在浏览一个文件来寻找特定的词 Char[50]=getline(file,/n) 使用 getline 将每一行存储到一个 char 数组中以与我要查找的字符串进行比较 If( “”==char[
C++ 入门 1.4.4 — EOF 的重要性以及如何编写没有 EOF 就结束的代码？
引用两个问题: Incorrect output from C++ Primer 1.4.4 Confused by control flow execution in C++ Primer exam
c++ - 为什么 iostream::eof 在循环条件(即 `while (!stream.eof())` )内被认为是错误的？
我刚刚在 this 中找到一条评论回答说在循环条件中使用 iostream::eof “几乎肯定是错误的”。我通常使用类似 while(cin>>n) 的东西——我猜它会隐式检查 EOF。为什么使用
c++ - 为什么 iostream::eof 在循环条件(即 `while (!stream.eof())` )内被认为是错误的？
我刚刚在 this 中找到一条评论回答说在循环条件中使用 iostream::eof “几乎肯定是错误的”。我通常使用类似 while(cin>>n) 的东西——我猜它会隐式检查 EOF。为什么使用
c++ - 为什么 iostream::eof 在循环条件(即 `while (!stream.eof())` )内被认为是错误的？
我刚刚在 this 中找到一条评论回答说在循环条件中使用 iostream::eof “几乎肯定是错误的”。我通常使用类似 while(cin>>n) 的东西——我猜它会隐式检查 EOF。为什么使用

行者123

个人简介

我是一名优秀的程序员,十分优秀！

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城

C 未检测到 EOF