Printable View
Hey, I'm picking up C++. I have a question about the evaluation of the following:
It's my understanding that this evaluates to true as long as the input is not end-of-file or a non int. But what is it that is returned exactly? Tried this:Code:int var;
if(std::cin >> var)
//do something
I have found out that it's a void* but, it's not an object (hence the cast), well what is it then?Code:while( (void *ret = (std::cin >> var)) ){
printf("%d, %p, %d\n", var, ret, *((int*)(ret)));
}
It's probably the safe-bool idiom, which means it will be either 0 or an arbitrary function address, the actual value being of no consequence whatsoever.
All we're supposed to care about is that it's implicitly convertible to a bool (true/false).
if (std::cin >> something)
Two things happen in that statement. First, operator >> does its work and returns a reference to the object. Doing this allows programmers to combine method calls, in this way:
std::cin.operator>>(std::cin, something).operator>>(std::cin, otherThing);
That looks weird, probably, but that's the idea in general. It's only because operators are used that it looks like this:
std::cin >> something >> otherThing;
Secondly, the std::cin object turns to a bool type in Boolean contexts, where you are evaluating the truth of a statement. Actually, std::cin converts to void* first and then the pointer is tested for 0. So, when the stream is bad but needs to be evaluated as a bool it turns into a null pointer.
So that's the full explanation.
I would just like to note something about chaining stream operations -- extracting stuff in particular -- here. If you chain operations and there is a stream error in the middle of the chain, the stream will go into a bad state, but it will be difficult to know exactly where the error occurred. It could have been any part of the chain.
Thanks for the explanation. I guess for practical purposes the only thing that should matter is that it works, but I always get curious about what's going on in the background when given abstractions. I've been doing C for a while now and it seems a bit more transparent in this regard, again thanks.
It is interesting that you are not so curious as to why the conversion is to void* rather than directly to bool :)
iMalc mentioned the safe bool idiom, but this technique is not the safe bool idiom. However, this article on the safe bool idiom explains this technique as well: The Safe Bool Idiom. In the next version of C++, it is expected that we will have explicit conversion functions, thus eliminating the need for the safe bool idiom (and this convert to void* technique).
If you know, by all means, spill the beans. :)Quote:
Originally Posted by laserlight
Thanks for the link laserlightQuote:
Originally Posted by laserlight
I think the article discusses that, and the danger of implicit conversion operators.Quote:
Originally Posted by Subsonics
Hence a workaround has been devised to do boolean testable without the side effects.
Yes, having read it now, I realize I drew the wrong conclusion from the name of the link. I think I will come back to it again later, some of that was beyond what I have learned about C++ so far.Quote:
Originally Posted by Elysia
Will streams be used differently or different at all because of this change in the standard?Quote:
Originally Posted by laserlight
I doubt that they will change except that perhaps they will use an explicit bool operator instead of conversion to void*. But that remains to be seen.
If you have been misusing the conversion to void*, you will find that your code will no longer compile :)Quote:
Originally Posted by whiteflags