Why is my professor using two getchar();? [closed]

Answer 1

The best better way is not to add any code to try and keep the console window open: start your program right from the console window.

If you must start your program from the IDE and want the program to not terminate before the user presses Enter, one single getchar() should do it.

The second best better way to make the program terminate after the user presses a key, is to always make sure there are no inputs pending and use one single getchar().

The reason your teacher uses 2 getchar(), I guess, is that there is already a character in the input buffer from previous inputs. To consume all characters from the inputs, up to and including the ENTER, this is usual:

int ch;
/* ... */
printf("Press Enter"); fflush(stdout);
while ((ch = getchar()) != '\n' && ch != EOF) /* void */;

Answer 2

Because one hit of the "enter" button generates two characters on Windows, see wikipedia. At least it used too, long time ago in a galaxy far far away ...

Answer 3

He wants the console to stay open and wait for the user to press a key. I think to remember that depending on what happens in your professors program above the "getchar()". There might still be something in the buffer, so he added a second "getchar()". Not exactly the most elegant way to solve the problem.

Edit: Here is a little example. There is still a remaining "\n" in the buffer from the "scanf()" If you add a second "getchar()", you get the expected result. You have to flush the buffer before the "getchar()".

#include <stdio.h>

main()
{
int input;
scanf("%d", &input);
printf("The input is %d\n", input);
getchar();
return 0;
}

Edit 2: Here is a solution taken from here.

int c;
printf( "Press ENTER to continue... " );
fflush( stdout );
do c = getchar(); while ((c != '\n') && (c != EOF));

Answer 4

It is a naive solution to the unused buffered input problem. Your prof recognises the problem, but it seems does not know how to solve it properly.

If you use formatted input, only characters entered that match the format specifier are used. So if for example the last input requested a decimal integer using %d, you might enter at the console:

123<newline>

The formatted input will consume the "123", leaving the <newline> buffered. An unformatted input such as getchar() will consume that and return immediately. Since this is not what you want, your prof has used the "just add another getchar() kludge". This works only if the user enters the expected input. A hamfisted typist might type:

123w<newline>

Now the first getchar() gets the 'w', the second gets the <newline>, and your program terminates before you intended it to, and in a GUI environment, if the terminating process owns the window it is running in, then the OS closes it.

A more robust solution is to repeatedly call getchar() until the <newline> is found:

while( getchar() != '\n' ) { /*do nothing*/} ;
getchar() ; /* wait */

Of course if the previous input was a character, you need to check it was not already a <newline>:

while( ch != '\n' && getchar() != '\n' ) { /*do nothing*/} ;
getchar() ; /* wait */

Rather than putting the flush loop at the end just before the 'wait' input call, it is better to perform the buffer flush after every input that requires it. This is because that is where you know you need it, and how it should be coded. I tend to write wrapper functions for the input types I need.

Answer 5

To fetch a remaining "\n" from the buffer so that the app closes.