C++ : if condition is evaluated with bad input (float) despite supposedly checking for it with cin.clear() and cin.ignore()

Question

I thought I understood handling bad input with cin.clear() and cin.ignore(), like it is explained here, but in the following example

#include <iostream>
#include <limits>
using namespace std; //I know that this isn't good practice.

int main () {
    int a, b;

    while (cout << "Input some int: " && !(cin >> a)) {
        cout << "Wrong datatype!\n";
        cin.clear();
        cin.ignore(numeric_limits<streamsize>::max(), '\n');
    }

    while (cout << "Input some int: " && !(cin >> b)) {
        cout << "Wrong datatype!\n";
        cin.clear();
        cin.ignore(numeric_limits<streamsize>::max(), '\n');
    }

    if (a > 1) cout << "Some event.\n";
    if (b > 1) cout << "Some other event.\n";

    return 0;
}

the behavior I want is only present when the unwanted input is some character. So if I enter x and y, I will again be asked for two ints and get the appropriate outputs, same if I enter a char and an int two times.

However: If I input, say, 2.3, I will get

Input some int: Wrong datatype!

but won't have a chance to correct my input, since the result invariantly outputs "Some event." The second prompt just accepts the float right away.

Answer 1

What's happening, actually, is the 2 in 2.3 is being accepted by the first prompt, leaving .3 in the input buffer. The Wrong datatype! you are seeing is from your second prompt, seeing a ., which is not a valid character for an integer. You then, I assume, enter an integer which is accepted by your second prompt.

Answer 2

The problem here is when you enter something like 2.3 to a int cin is okay with that. It reads the 2, sees the . so it stops reading and stores the 2 in the variable and leaves the .3 in the buffer for the next call. So, you pass the first loop, get to the second loop, and then you fail as it tries to read in the . into b. Then you clear the .3 and you can enter another input. If you enter another 2.3 the same thing will happen and b will get 2 and the program continues on.

The "bullet proof" way to read in input is to read it in as a std::string and then parse that to make sure the full input was good. That would look like

std::string line;
while (cout << "Input some int: " && std::getline(cin, line)) {
    std::stringstream ss(line);
    ss >> a;
    if (ss.eof()) // we did consume all the input
        break;
    else
        cout << "Wrong datatype!\n";
}

while (cout << "Input some int: " && std::getline(cin, line)) {
    std::stringstream ss(line);
    ss >> b;
    if (ss.eof()) // we did consume all the input
        break;
    else
        cout << "Wrong datatype!\n";
}

Answer 3

This fundamental approach is fragile, and error-prone.

Your obvious intent is to accept a line of input, and process it. If so, then the correct function to do that is std::getline(). That's what its purpose is. That's exactly what it does. The >> operator does not do that. That's not what it's for. Of course, by using the various auxiliary methods, like ignore(), and clear(), one can still achieve that goal, but, as you've discovered, using those functions correctly is not intuitive. Of course, you can spend copious time pouring over their documentation to understand their every semantic behavior, but why bother, when you can simply use std::getline(), and then move on to something else. It's simply easier to do that.

Of course, once a line of input is received, you would like to parse it into an integer. Now is the correct time to use >> to parse it:

std::string line;

if (std::getline(line, std::cin))
{
    std::istringstream i{line};

    int n;

    if (i >> n)
    {
           // Input parsed
    }
}

Isn't this simpler, more straightforward, and less of a gotcha?. Of course, entering "2.3" here will result in the >> operator parsing the "2", and succeeding, leaving ".3" unparsed. If you would like to detect this situation, simply use get() to see what's left in the std::istringstream. Perhaps accept any trailing whitespace, if you wish.

Answer 4

When you input "2.3", cin will stop at '.', and interpret '2' as the desired input.

Then, you will clear cin, when the '.' is encountered, discarding 3.

If you then input a new integer, it will accept it.

Answer 5

Many answers here suggest the use of std::getline and string parsing, either using the string functions or stringstreams. This is quite inefficient and not the way the streams are supposed to be used.

Instead, parse the data when it is still in the input stream:

#include <iostream>
#include <cctype>
#include <limits>

struct read_int {
    int& a;

    read_int(int& aa) : a{ aa } { }
    friend std::istream& operator >>(std::istream& is, read_int& ri) {
        char delim;
        while(!(is >> ri.a) || (delim = is.get(), delim != '\n' && !std::isspace(delim))) {
            std::cerr << "Bad!\n";
            is.clear();
            is.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
        }
        return is;
    }
};


int main() {
    int a, b;
    std::cin >> read_int(a) >> read_int(b);
    std::cout << a << ' ' << b;
    return 0;
}

This function will accept input like "4 5" or "4\n6" alike, but requests a new input for data like "4.2", discarding everything read before.