The code below works for the first question (first half of the code), the program then proceeds to the second questin, but it never stops to await the answer.
Even without looking at the code, I can guess what the problem is with good accuracy.
It's probably the single most common problem when people who aren't used to stream input in C/C++ try to read single characters.
Here's how it works. A stream in C/C++ really isn't much more than an array of characters. When you read a character, you increment an index. The basics of this can be faked with a simple program in C.
#include <stdio.h>
static const char stream[BUFSIZ] = "Default initialization";
static size_t loc = 0;
// Single character input
int cget( void );
int main( void )
{
int ch;
while ( ( ch = cget() ) != EOF )
putchar( ch );
putchar( '\n' );
return 0;
}
int cget( void )
{
if ( stream[loc] == '\0' )
return EOF;
return stream[loc++];
}
Here's where it gets interesting and where the problem comes from. Every character you type when filling the stream is saved in the stream. If you type "A" and then hit enter to send it to the program, the enter is saved as part of the stream too. In my little example program above, it would look like this.
#include <stdio.h>
static const char stream[BUFSIZ] = "A\n";
static size_t loc = 0;
// Single character input
int cget( void );
int main( void )
{
int ch;
while ( ( ch = cget() ) != EOF )
putchar( ch );
return 0;
}
int cget( void )
{
if ( stream[loc] == '\0' )
return EOF;
return stream[loc++];
}
Now, if you change the logic of the code to read two characters like your program tries to do, you get this.
#include <stdio.h>
static const char stream[BUFSIZ] = "y\ny\n";
static size_t loc = 0;
// Single character input
int cget( void );
int main( void )
{
int answer;
//ask if there are new patients
printf ("if new patients type 'y'.\n");
answer = cget();
if (answer == 'y' || answer == 'Y')
printf("something\n");
// ask if they want to see the list of patients
printf ("wanna see list: type 'y'.\n");
answer = cget();
if (answer == 'y' || answer == 'Y')
printf("something else\n");
return 0;
}
int cget( void )
{
if ( stream[loc] == '\0' )
return EOF;
return stream[loc++];
}
The second test fails because you're looking at '\n' instead of 'y'. The enter stays in the stream and becomes the next character read. That's the problem, and here's why it happens.
When the stream is empty and you try to read from it, all execution stops and waits for you type something. This is a refill operation called a blocking read. If the stream isn't empty, whatever is in it will be used without blocking. Here's what happens when you run your program.
The first call to scanf() causes a blocking read and you type 'y'. But you also have to hit enter or nothing will happen because input in C/C++ waits for a newline character before returning. The stream at that point contains "y\n". scanf() then extracts the 'y' and uses it in the answer variable.
Now, the second call to scanf() doesn't cause a blocking read because there's still a '\n' in the stream. The '\n' is extracted and saved in the answer variable and used in the test right away. In the end it looks like scanf() is skipped when it's doing exactly what you told it to, but not what you really wanted.
All of this is why I hate C/C++ stream I/O. It's just not intuitive.
The way to fix the problem is to read complete lines from the stream including the '\n' and then parse the string with your program's logic. Another fix is to periodically empty the stream by reading and throwing away all of the characters that are there up to and including the next '\n'.
void flush_stdin( void )
{
int ch;
do
ch = getchar();
while ( ch != '\n' );
}
Offline 
Marked 
