Best way I know is to read a line into a std::string then use a stringstream to convert the string into an int. That way you can check the error state of the stringstream after the conversion:

#include <string>#include <sstream>#include <iostream>int main(){    std::string s;    std::cout << "Enter an int: ";    std::getline(std::cin,s);    std::istringstream is(s);    int i;    is >> i;    if(is.fail()) std::cout << "You do not have an int!\n";}

It is also worth checking that the stringstream is empty of anything but whitespace after the conversion since if you enter, say, 23.54, the stringstream will put 23 into the int and leave .54 in the stream ready for the next extraction.

I think I check it is empty by doing >> to a std::string and making sure that the stringstream DOES fail.

You can evaluate the stream in a boolean context to determine if it is in a valid state. Note that a failed read places the string in an invalid state. The typical reading code looks like this.

if (std::cin >> i1) { /* Success */ } else { /* Failure */ }

On success, the key is to determine why the reading failed. There are two possible explanations: the data inside the stream was invalid (you entered a non-integer), at which point you may ignore the first few characters, restore the state of the string to a valid one using std::cin.clear(), and read again.

The other explanation is that the end of the stream was reached, in which case std::cin.eof() returns true. You should then handle the fact that no more input will be received.

Your code attempts to read data into an integer. If it fails, it tries again with the exact same stream, which obviously will fail again. This is because neither failure nor clear will alter the data inside the stream.

Once the stream reaches an invalid state, you have to do something about the data it contains, such as removing the first character (which would be invalid), before trying the same reading attempt again.

Quote:Original post by BUnzaga
In the &#106avascript code I have been using, I would use something like i1=null. Is there something like that in C++?

The stream doesn't care about i1. If reading fails, i1 has not even been modified. The problem here is about the stream contents, not the integer.

Suppose you enter the text "Hello" at the prompt. So, the beginning of standard input is "Hello". Then, std::cin >> i1 attempts to read "Hello" as an integer. It fails, because "Hello" is not a valid integer, which places std::cin in an invalid state, leaves "Hello" in the stream, and does not modify the integer.

Your code then calls std::cin.clear() to notify std::cin that you are aware of the error. Note that the beginning of standard input is still "Hello", as no successful read operation has been performed so far. Then, your loop repeats, and you try to perform std::cin >> i1 again. Note that the contents or the input stream are still "Hello", because you have not done anything with the stream to change its contents, so the reading of "Hello" as an integer fails again.

Your code then calls std::cin.clear() again to notify std::cin that you are aware of the new error. Again, note that the beginning of standard input is still "Hello", as you have still not managed to perform a succesful read operation on your stream. Your loop repeats once more, and the code executes std::cin >> i1 for a third time. The input stream still starts with "Hello", because its contents have still not been altered by a successful read, so reading it as an integer fails once more.

This cycle repeats on and on, without any reason to stop. Basically, your program reaches the situation "the stream contains invalid data", to which you respond "do not worry, try again", where a sane answer would be "do not worry, remove the invalid data, then try again".