Error receiving inputs - c

Question

I have often seen cases where in a series of printf statements that ask for an input, certain
statements do not accept an input, i.e.
printf_statement1:
printf_statement2: /*Enter input here*/
i.e. before the user enters an input for statement1, statement2 is printed, that allows the user to enter an input, and then repeats the same with statement3 & statement4.
What prompts such a case?
I encounterd this, but not any more, in:
printf("\n\n\t\tName: ");
scanf("%s", name); //initially used gets
printf("\n\n\t\tType: ");
scanf("%c", &type);
printf("\n\n\t\tAddress: "); //initially used gets
scanf("%s", address);
printf("\n\n\t\tDate - of - Birth: ");
scanf("%s", dob); //initially used gets
Output:
Name:
Type: I enter something!
Address:
Date - of - Birth: I enter something!

Answer 1

I know this question is already marked as answered, but as fflush(stdin) makes me cringe I wanted to post an alternative to clearing stdin:
void clear_stdin(void)
{
int c;
do {
c = fgetc(stdin);
} while (c != '\n' && c != EOF);
}
This will clear any chars up until a new line or until EOF is encountered. (You could just stick the body and condition of the do..while into the condition of a while loop, but I prefer to write it that way.)
It'd be useful to call that function for example after wanting to read in a single char, to prevent subsequent prompts from seeming to be skipped if the user enters more than 1 character.
Also consider using fgets() or providing a width specifier with scanf() in order to prevent overflows.

Answer 2

to replace fflush(stdin) in "Jonathon Reinhart" answer , i suggest this function, which is standard compliant :
void clean_stdin(void)
{
int c;
do {
c = getchar();
} while (c != '\n' && c != EOF);
}

Answer 3

The root of the problem is that the "%c" conversion specifier doesn't skip over whitespace. Suppose you type "Joe" for the name; the input stream will contain the characters 'J', 'o', 'e', '\n'. The first call to scanf looks for a string ("%s" conversion specifier); it will consume 'J', 'o', and 'e', and leave the '\n' in the input stream. In response to the next prompt, you type a character like 'A', so the input stream now contains '\n', 'A', '\n'. The next call to scanf looks for a single character; it will consume the first newline and return, leaving 'A' and '\n' in the input stream.
Rather than flushing stdin (which is not a well-defined operation according to the language definition), it's better to avoid using the "%c" conversion specifier for interactive input; frankly, it's better to avoid using scanf for interactive input and use fgets instead.
A quick and dirty solution would be to change the type of type from a simple char to an array of char and read it as a string:
char type[2];
...
fgets(type, sizeof type, stdin);
This will skip over any newlines stuck in the input stream without having to flush anything. Then you'd just use type[0] for your type value.
Edit
If you don't want to change the type of type, you can do something like this:
#include <ctype.h>
...
while ((type = fgetc(stdin)) && isspace(type))
;
which will read individual characters from stdin until it sees a non-whitespace character.

Answer 4

Sometimes in cases like these, it is helpful to call fflush() on stdin before reading from it:
char name[40+1];
printf("\n\tName: ");
fflush(stdin);
scanf("%40s", name);
Depending on the circumstances, there may be a newline in the input buffer that causes your first scanf to get skipped (given no input).
Also note that you should specify the size of the buffer in scanf as to avoid buffer overflows.
A format specifier for scanf looks like this:
%[*][width][modifiers]type
width: Specifies the maximum number of characters to be read in the current reading operation
Thus, the %40s specifies that only 40 characters may be read in to the string. Note that the buffer is 41 characters, leaving room for the NULL terminator.
Edit: Some sources (like this and this) say that you should avoid calling fflush(stdin) and it is incorrect. However, the Linux man page states:
For input streams, fflush() discards any buffered data that has been fetched from the underlying file, but has not been consumed by the application.
Conforming to C89, C99, POSIX.1-2001, POSIX.1-2008.
The standards do not specify the behavior for input streams. Most other implementations behave the same as Linux.
Additionally: MSDN says nothing about calling fflush(stdin) other than the following:
If the stream is open for input, fflush clears the contents of the buffer.
One would think that if calling fflush(stdin) was such a problem, one of the two largest sources of documentation on fflush would have mentioned this.