Why do I have to press enter Twice?
c++, iostream
Solution
It seems to me that you are tossing too many `cin.ignore()` around, not knowing exactly why they are needed and when to put them there.
There are two common circumstances where `cin.ignore()` is needed to "make input work right":
- when mixing formatted and unformatted input;
- to recover from a formatted input error.
In both cases, you want to get rid of spurious characters from the input buffer; if there isn't any such character (which is probably what happens in your program), `cin.ignore()` will pause the execution and wait for user input - after all, you asked it to ignore some characters, and dammit, it will obey to its orders.
(although `ignore()` by default would "eat" just one character, whatever it may be, the execution is paused until a newline is found because by default `cin` is line buffered - new input is not examined until a newline is recieved)
Case 1:
`cin.ignore()` calls are often needed if you are performing an unformatted input operation (like `getline`) after performing a formatted input operation (i.e. using the `>>` operator).
This happens because the `>>` operator leaves the newline in the input buffer; that's not a problem if you are performing only formatted input operations (by default they skip all the whitespace before trying to interpret the input), but it's a problem if afterwards you do unformatted input: `getline` by default reads until it finds a newline, so the "spurious newline" left will make it stop reading immediately.
So, here you will usually call `cin.ignore(...)` call to get rid of the newline just after the last formatted input operation you do in a row, guaranteeing that the input buffer is empty. Afterwards, you can call `getline` directly without fear, knowing that you left the buffer empty.
It's a bad idea, instead, to put it before any `getline`, as you seem to do in your code, since there may be code paths that lead to that `getline` that have the input buffer clean, so the `ignore` call will block.
Case 2:
when `istream` encounters an error in a formatted input operations, it leaves the "bad" characters in the buffer, so if you retry the operation you get stuck endlessly, since the offenders are still there. The usual `clear()/ignore()` idiom comes to the rescue, removing the whole offending line from the input buffer.
Again, you don't put the `clear()/ignore()` sequence at random, but only after you get an input error from a formatted input operation (which sets the failbit of the stream).
Now, aside from these cases, it's uncommon to use `cin.ignore()` (unless you actually want to skip characters); don't spread it around randomly "just to be safe", because otherwise you will encounter the problem you described.
Problem
For some reason in my program when I reach a certain spot, I have to press Enter twice in order to get it to submit. I added the clear to keep it from skipping input and the ignore() to keep it from keeping any extra characters in the buffer. I enter my input and then it drops down to a new line, I hit Enter again and it enter the input and continues the program no problem but I'm wondering why. Here's a code snippet: ``` cin.ignore(); cout << "Enter Student Major (ex. COSC): "; cin.getline(student.major, 6); for(int i = 0; i < sizeof(student.major); i++) student.major[i] = toupper(student.major[i]); cin.clear(); cin.ignore(numeric_limits<streamsize>::max(), '\n'); ``` Any suggestions?