为什么当我提取到`char`与`int`时，IOStream的EOF标志行为会有所不同？

Question

Recently I've come across a bug in my software that was caused by a stringstream object that had it's EOF flag set before I expected it. Even though I managed to found out what happened, I was not able to find out why this is happening. An example:

stringstream test ("a b");
char temp, temp2;

test >> temp >> temp2;
cout << "eof: " << test.eof() << endl;  

When run, this shows:

eof: 0

This is the output I would expect. (I would expect the stringstream to set the EOF flag to 1 when i attempt to read something again)

However, when I make a small change to the above example:

stringstream test ("4 2");
int temp, temp2;

test >> temp >> temp2;
cout << "eof: " << test.eof() << endl;

the output shows:

eof: 1

Why does the EOF flag get set in this situation, but not in the previous one?

Answer 1

When you're extracting one character at a time, the stream can't know that the EOF has been reached until you try to extract a character that isn't there.

But when you're extracting formatted data into a type like int , the parser attempts to pull as many characters out of the stream as it can to form the number; the "tries to extract a character that isn't there" part will occur as part of this process (the final "iteration", in fact), so EOF can be set.

Answer 2

operator>> skips whitespace characters by default, so the first read into a char will read a , the second will skip and read b , a third would reach the end of the string and fail, setting the eof flag.

In the int case, multiple characters can be read while parsing an int because an int may be represent by multiple digits. While reading the integer a second read attempt will be made after reading the 2 . This will set the eof flag for the stream although the read of the int will succeed.

This is why you should check !fail() and not good() to see if a read operation succeeded and why the conversion of a stream to bool (or void* in C++03) also uses !fail() .