ostream insertion operator, left to right?, or right to left?

[e2easy]

Consider the following line of C++ ...

std::cout<<myfna()<<myfnb();

...but assume myfna(), and myfnb() causes side-effects, then it matters whether this line is evaluated left to right, or right to left.

So what does the standard say? (ECMA, whatever) Is it defined?

I always assumed it was left to right (myfna() then myfnb()). I rely on other expressions being evaluated left to right (especially when I use || and && operators) - and on my (non-Microsoft) computer/os, running my (non-Microsoft) compiler - everything is fine.

I can't think of a good reason why a particular compiler might evaluated this right to left ? But on Windows running Visual C++ it is right to left.

Is there really no standard or convention here? Or does Microsoft disregard it?

[Duthomhas]

http://en.wikipedia.org/wiki/Sequence_point

The order of evaluation is undefined. If the side effects make a difference, use temporary results:

{ // open brace = create new local context
  int myfna_result = myfna();
  std::cout << myfna_result << myfnb();
} // the temp var destroyed here 

Since the ';' is a sequence point, you then guarantee that myfna() is called before myfnb().

Hope this helps.

[e2easy]

Thanks Duoas. Getting around it is easy, but I'm just surprised a standard isn't defined.

Out of interest, is this (left to right, or right to left) defined in Java?

[Duthomhas]

It is defined: the standard says your results may vary. There are very practical reasons for that, but the most compelling is simply logical: if you are asked to do two things at once, but you can only do one at a time, which do you do first? As long as they are both done at some specific time then who can complain? Hence, the existence and purpose of sequence points.

(Remember, cout is sequential, but cout cannot output a function call, it can only output the result of a function call. Since the statement lists three things to be done at one time [an output and two function calls] you can only guarantee that the functions are called some time before the output simply because the output is dependent on the results of the function calls.)

I don't remember how Java defines it. But then again, I've never cared too much because (1) it is very easy to always write code that follows a specific sequence by separating dependent procedures with sequence points (which exist in all languages), and (2) side-effects cannot be separated from function results unless the function is referentially transparent (in other words, you have to account for the side effects).

Hope this helps.