How to properly flush stdin in fgets loop

by

There is unfortunately a lot of confusion about “flushing input” in C. The confusion arises almost entirely from one of the strange facts about the popular-but-flawed scanf function: it generally does not read full lines of input, and it generally leaves the newline character \n on the input stream after it converts its input. For example, if you write a program that says

printf("Type a number:\n");
scanf("%d", &n);

and if the user types “123” and hits the Return key, the number 123 will get stored into the variable n, but the \n character corresponding to the Return key will be left on the input stream. If the next thing your program does is to call fgets, or getchar, imagining that you’ll begin reading the next line of input the user typed, your program will instead immediately read that leftover newline. It will seem as if the user typed an extra blank line, or something.

This problem is ridiculously widespread. Vast numbers of beginning C programmers have gotten stuck on it. In a nutshell, there are three recommended ways of fixing it:

  1. After calling a function like scanf that leaves the newline in the input buffer, and before calling a function like getchar or fgets that expects to start on a new line, use the little loop while((c = getchar()) != '\n' && c != EOF) to read and discard the newline that scanf left on the input buffer.

  2. Don’t use scanf at all, or if you do, don’t try to mix it with calls to getchar or fgets.

  3. (popular but badly problematic) Call fflush(stdin) to flush the unwanted input.

The problems with #3 have been widely discussed, so I won’t say any more about those problems or that solution. The recommended “portable” alternative is #1, but it obviously works only if there is at least one unwanted newline in the input waiting to be flushed. If not, solution #1 will wrongly read and discard a line of wanted input, instead.

So you can’t use #1 everywhere. You can’t sprinkle it randomly in your program; you can’t use it everywhere you might have used fflush(stdin). In general, as mentioned already, you’ll need it only after calling scanf and before calling getchar or fgets.

In the code fragment in the question, there may not have been a need to use solution #1 at all. The fgets function is perfectly capable of cleanly reading individual lines of input all by itself. No additional flushing of input or discarding of newlines is necessarily required. (If there was a call to scanf down underneath do_something(), however, additional newline handling might have been necessary.)

More Related Contents:

  1. Using fflush(stdin)
  2. How do I read a string entered by the user in C?
  3. How to read a line from the console in C?
  4. I am not able to flush stdin. How can I flush stdin in C?
  5. setvbuf not able to make stdin unbuffered
  6. Using fseek with a file pointer that points to stdin
  7. Does reading from stdin flush stdout?
  8. How to clear stdin before getting new input?
  9. fflush(stdin) function does not work
  10. Read from file or stdin
  11. C read binary stdin
  12. Read input.txt file and also output.bmp file from terminal (C-programming)
  13. Writing to stdin and reading from stdout (UNIX/LINUX/C Programming)
  14. How to read from stdin with fgets()?
  15. Scanf/Printf double variable C
  16. Is there any way to peek at the stdin buffer?
  17. Why do i have to input EOF 3 times when using fgets?
  18. Reading from stdin
  19. How to read terminal’s input buffer immediately after keypress
  20. Program gives unstable output? [closed]
  21. With arrays, why is it the case that a[5] == 5[a]?
  22. size_t vs. uintptr_t
  23. How to increment a pointer address and pointer’s value?
  24. Measure time in Linux – time vs clock vs getrusage vs clock_gettime vs gettimeofday vs timespec_get?
  25. Why must the variable used to hold getchar’s return value be declared as int?
  26. Are literal strings and function return values lvalues or rvalues?
  27. x86_64 ASM – maximum bytes for an instruction?
  28. Interprocess mutex with pthreads
  29. How is this const being used?
  30. Providing/passing argument to signal handler

Leave a Comment