C - how to handle user input in a while loop

Question

I'm new to C and I have a simple program that takes some user input inside a while loop, and quits if the user presses 'q':

while(1)
{
   printf("Please enter a choice: \n1)quit\n2)Something");
   *choice = getc(stdin);

   // Actions.
   if (*choice == 'q') break;
   if (*choice == '2') printf("Hi\n");
}

When I run this and hit 'q', the program does quit correctly. However if I press '2' the program first prints out "Hi" (as it should) but then goes on to print the prompt "Please choose an option" twice. If I enter N characters and press enter, the prompt gets printed N times.

This same behaviour happens when I use fgets() with a limit of 2.

How do I get this loop working properly? It should only take the first character of input and then do something once according to what was entered.

EDIT

So using fgets() with a larger buffer works, and stops the repeated prompt issue:

fgets(choice, 80, stdin);

This kind of helped: How to clear input buffer in C?

if (*choice == '2') printf("Hi\n"); else printf("Oops: %x\n", *choice & 0xff ); — wildplasser
– wildplasser, Commented Oct 1, 2014 at 14:57
I'd probably use fgets with a larger buffer, say 80 chars or so. Or stick another loop in there that reads until the next newline. — Fred Larson
– Fred Larson, Commented Oct 1, 2014 at 14:58
instead of doing while(1) why not just say while(choice != 'q'). Then eliminate the first if statement all together — urnotsam
– urnotsam, Commented Oct 1, 2014 at 14:59
google clearing the input buffer (don't use fflush though), you can't getc reliably on a dirty buffer — Elias Van Ootegem
– Elias Van Ootegem, Commented Oct 1, 2014 at 15:01
@Dylan When you press 2<enter>, the 2 and a newline are both queued for reading on stdin. So your getc loop consumes the 2, runs again to consume the newline. This produces the extra prompt, but since you don't have a switch case for \n, that's all it does. Then it finally prints the prompt again and waits for the next input. The main idea to take away is that getc requires you to manage the newlines in the input buffer yourself, which can be painful. The fgets approach is generally simpler. — Gene
– Gene, Commented Oct 1, 2014 at 15:13

Elias Van Ootegem · Accepted Answer · 2014-10-01 15:52:31Z

3

When you getc the input, it's important to note that the user has put in more than one character: at the very least, the stdin contains 2 chars:

2\n

when getc gets the "2" the user has put in, the trailing \n character is still in the buffer, so you'll have to clear it. The simplest way here to do so would be to add this:

if (*choice == '2')
    puts("Hi");
while (*choice != '\n' && *choice != EOF)//EOF just in case
    *choice = getc(stdin);

That should fix it

For completeness:
Note that getc returns an int, not a char. Make sure to compile with -Wall -pedantic flags, and always check the return type of the functions you use.

It is tempting to clear the input buffer using fflush(stdin);, and on some systems, this will work. However: This behavior is undefined: the standard clearly states that fflush is meant to be used on update/output buffers, not input buffers:

C11 7.21.5.2 The fflush function, fflush works only with output/update stream, not input stream

However, some implementations (for example Microsoft) do support fflush(stdin); as an extension. Relying on it, though, goes against the philosophy behind C. C was meant to be portable, and by sticking to the standard, you are assured your code is portable. Relying on a specific extension takes away this advantage.

edited Oct 1, 2014 at 15:52

answered Oct 1, 2014 at 15:10

Elias Van Ootegem

76.7k10 gold badges123 silver badges160 bronze badges

Sign up to request clarification or add additional context in comments.

3 Comments

Jonathan Leffler Over a year ago

Also note that getc() returns an int and that you should test for EOF and handle it appropriately.

Elias Van Ootegem Over a year ago

@JonathanLeffler: That's why we compile using -Wall -pedantic... I'll add that to my answer, seeing as we're trying to be complete ;-P

IllegalCactus Over a year ago

Thanks for the extra bit on fflush(). That while loop fixes the issue.

Tyler Durden · Accepted Answer · 2014-10-01 16:53:09Z

What seems to be a very simple problem is actually pretty complicated. The root of the problem is that terminals operate in two different modes: raw and cooked. Cooked mode, which is the default, means that the terminal does not read characters, it reads lines. So, your program never receives any input at all unless a whole line is entered (or an end of file character is received). The way the terminal recognizes an end of line is by receiving a newline character (0x0A) which can be caused by pressing the Enter key. To make it even more confusing, on a Windows machine pressing Enter causes TWO characters to be generated, (0x0D and 0x0A).

So, your basic problem is that you want a single-character interface, but your terminal is operating in a line-oriented (cooked) mode.

The correct solution is to switch the terminal to raw mode so your program can receive characters as the user types them. Also, I would recommend the use of getchar() rather than getc() in this usage. The difference is that getc() takes a file descriptor as an argument, so it can read from any stream. The getchar() function only reads from standard input, which is what you want. Therefore, it is a more specific choice. After your program is done it should switch the terminal back to the way it was, so it needs to save the current terminal state before modifying it.

Also, you should handle the case that the EOF (0x04) is received by the terminal which the user can do by pressing CTRL-D.

Here is the complete program that does these things:

#include    <stdio.h>
#include    <termios.h>
main(){
    tty_mode(0);                /* save current terminal mode */
    set_terminal_raw();         /* set -icanon, -echo   */
    interact();                 /* interact with user */
    tty_mode(1);                /* restore terminal to the way it was */
    return 0;                   /* 0 means the program exited normally */
}

void interact(){
    while(1){
        printf( "\nPlease enter a choice: \n1)quit\n2)Something\n" );
        switch( getchar() ){
            case 'q': return;
            case '2': {
               printf( "Hi\n" );
               break;
            }
            case EOF: return;
        }
    }
}

/* put file descriptor 0 into chr-by-chr mode and noecho mode */
set_terminal_raw(){
    struct  termios ttystate;
    tcgetattr( 0, &ttystate);               /* read current setting */
    ttystate.c_lflag          &= ~ICANON;   /* no buffering     */
    ttystate.c_lflag          &= ~ECHO;     /* no echo either   */
    ttystate.c_cc[VMIN]        =  1;        /* get 1 char at a time */
    tcsetattr( 0 , TCSANOW, &ttystate);     /* install settings */
}

/* 0 => save current mode  1 => restore mode */
tty_mode( int operation ){
    static struct termios original_mode;
    if ( operation == 0 )
        tcgetattr( 0, &original_mode );
    else
        return tcsetattr( 0, TCSANOW, &original_mode ); 
}

As you can see, what seems to be a pretty simple problem is quite tricky to do properly.

A book I can highly recommend to navigate these matters is "Understanding Unix/Linux Programming" by Bruce Molay. Chapter 6 explains all the things above in detail.

Thanks! I saw switching the terminal mode being offered as a solution on some other question but wasn't sure how to go about it. Problem is fixed now but this is an interesting aspect I didn't know about before.

Michael S. Miller · Accepted Answer · 2014-10-01 15:25:35Z

1

The reason why this is happening is because stdin is buffered.

When you get to the line of code *choice = getc(stdin); no matter how many characters you type, getc(stdin) will only retrieve the first character. So if you type "foo" it will retrieve 'f' and set *choice to 'f'. The characters "oo" are still in the input buffer. Moreover, the carriage return character that resulted from you striking the return key is also in the input buffer. Therefore since the buffer isn't empty, the next time the loop executes, rather than waiting for you to enter something, getc(stdin); will immediately return the next character in the buffer. The function getc(stdin) will continue to immediately return the next character in the buffer until the buffer is empty. Therefore, in general it will prompt you N number of times when you enter a string of length N.

You can get around this by flushing the buffer with fflush(stdin); immediately after the line *choice = getc(stdin);

EDIT: Apparently someone else is saying not to use fflush(stdin); Go with what he says.

answered Oct 1, 2014 at 15:25

Michael S. Miller

4371 gold badge8 silver badges18 bronze badges

3 Comments

IllegalCactus Over a year ago

I've heard fflush() is supposed to be avoided too, but thanks for the explanation of input buffers. Making a lot more sense now.

Elias Van Ootegem Over a year ago

@Dylan: Added to my answer why fflush(stdin); should be avoided. Basically: its behavior is undefined, and undefined behavior is bad

Jonathan Leffler Over a year ago

See Using fflush(stdin)? for more information. Note that it is defined and supported on Windows, and (despite some evidence in manual pages to the contrary) is not supported elsewhere in practice.

Collectives™ on Stack Overflow

C - how to handle user input in a while loop

3 Answers 3

3 Comments

1 Comment

3 Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

3 Comments

1 Comment

3 Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related