Thread: Iterator quandary

Originally Posted by christop

It seems to me that order of operation/precedence is being confused with order of evaluation. C++ clearly defines precedence but leaves order of evaulation up to the implementation in a lot of cases. So something as simple as int a = *p++; could be evaluated as if it were written as either int *tmp = p; ++p; int a = *tmp; or as int a = *p; ++p; (there is no externally visible difference between the two). Even things like the order that function call arguments are evaluated is implementation-defined.

But something like Object a = *p++;, which overloads operator*, surely must be evaluated as if it were written as Object *tmp = p; ++p; Object a = *tmp;, right? Or does C++ leave that implementation-defined as well?

Well I couldn't get the same pointer-like behavior when defining a class and compiling under gcc/g++. (Rather unpleasant surprise, to say the least.) Which is why I decided to go with a different approach altogether. I wanted to make it easy for users to interface with my library. But yeah, just a subtle flaw in the language I guess.

Originally Posted by christop

I wouldn't really call it a "flaw". It's just an implementation detail, and the application has to be written in a way that it doesn't care about the order an expression is evaluated.

Should a "spade" be called by any other name? If a compiler can convert the code "*ptr++" to "*ptr; ++ptr;", it stands to reason it could do the same for objects which override those operators. As it is, the facility is almost useless.