How can std::cin return a bool and itself at the same time?

Question

I'm reading a book on C++ that says that if I use the >> operator it returns the object at the left side of the operator so in this example

std::cin >> value1;

the code returns std::cin.

But if I do this

while(std::cin >> value1)

My code will be in the loop until there is a std::cin error so that must mean that the operator returns a bool that is true when std::cin does not fail and false when std::cin fails.

Which is one is it?

Answer 1

[...] so that must mean that the operator returns a bool [...]

Nope, it returns std::cin (by reference). The reason why while(std::cin >> value); works is because std::istream (which is the type of std::cin) has a conversion operator.

A conversion operator basically permits a class to be implicitly (if it is not marked explicit) to be converted to a given type. In this case, std::istream defines its operator bool to return whether an error (typically failbit) occurred;

_{[std::ios_base::operator bool()]}

Returns true if the stream has no errors and is ready for I/O operations. Specifically, returns !fail().

---

explicit operator bool() const;

Note than even though the operator is explicit (which shouldn't allow implicit conversions like if (std::cin);), the qualifier is ignored when used in a context that requires a bool, like if, while loops and for loops. Those are exceptions though, not rules.

Here is an example:

if (std::cin >> value);  //OK, a 'std::istream' can be converted into a 'bool', which 
                         //therefore happens implicitly, without the need to cast it: 

if (static_cast<bool>(std::cin >> value)); //Unnecessary

bool b = std::cin >> value;  //Error!! 'operator bool' is marked explicit (see above), so 
                             //we have to call it explicitly:

bool b = static_cast<bool>(std::cin >> value); //OK, 'operator bool' is called explicitly

Answer 2

std::istream (the class which std::cin is an object of) has the following member function:

explicit operator bool() const;

It returns false if the object is in an error state, and true otherwise. This is why the while(std::cin >> value1) construct works. Before C++11, it had this non explicit function instead:

operator void*() const;

Which returned a null pointer if the object was in an error state, serving the same purpose.

Answer 3

std::cin is of type std::istream (which is just a typedef of std::basic_istream<char>)

If you see the different overloaded operator>> for basic_istream, all of them are returning a reference to basic_istream. So one thing is cleared up that the operator>> here, doesn't return a bool but instead, it returns "std::cin" itself. You won't see any operator>> there returning a bool value.

So the question is now, how does it convert the std::basic_istream to bool?
The answer is: A conversion operator is being called for this purpose.

std::basic_istream inherits a operator bool() from its parent std::basic_ios

explicit operator bool() const;

which makes it possible to convert a std::basic_istream object to bool. One can easily wonder that it is marked explicit (see why is it marked explicit) and still it is implicitly converted to bool in an if or while.

The answer to this question is that if or while use the explicit conversion "implicitly". (see this answer by @R. Martinho Fernandes). So if, while and for are one of the places where this "contexual conversion" to bool happens implicitly.

Answer 4

Operations on streams return a reference to the stream.

So, not a bool.

You can stick the result into an if condition for the same reason that you can do this:

void* ptr = foo();
if (ptr) { /*...*/ }

And, for that matter, this:

int x = foo();
if (x) { /*...*/ }

Both ptr and x here can be converted to a bool for use in the condition. In the case of std::cin, the conversion is achieved by an operator bool() within the std::ostream class that was explicitly (pun intended) added for this exact task.