28

the following code:

myQueue.enqueue('a');
myQueue.enqueue('b');
cout << myQueue.dequeue() << myQueue.dequeue();

prints "ba" to the console

while:

myQueue.enqueue('a');
myQueue.enqueue('b');
cout << myQueue.dequeue();
cout << myQueue.dequeue();

prints "ab" why is this?

It seems as though cout is calling the outermost (closest to the ;) function first and working its way in, is that the way it behaves?

Jim Lewis
  • 39,858
  • 6
  • 80
  • 93
finiteloop
  • 4,415
  • 8
  • 37
  • 61

3 Answers3

31

There's no sequence point with the << operator so the compiler is free to evaluate either dequeue function first. What is guaranteed is that the result of the second dequeue call (in the order in which it appears in the expression and not necessarily the order in which it is evaluated) is <<'ed to the result of <<'ing the first (if you get what I'm saying).

So the compiler is free to translate your code into some thing like any of these (pseudo intermediate c++). This isn't intended to be an exhaustive list.

auto tmp2 = myQueue.dequeue();
auto tmp1 = myQueue.dequeue();
std::ostream& tmp3 = cout << tmp1;
tmp3 << tmp2;

or

auto tmp1 = myQueue.dequeue();
auto tmp2 = myQueue.dequeue();
std::ostream& tmp3 = cout << tmp1;
tmp3 << tmp2;

or

auto tmp1 = myQueue.dequeue();
std::ostream& tmp3 = cout << tmp1;
auto tmp2 = myQueue.dequeue();
tmp3 << tmp2;

Here's what the temporaries correspond to in the original expression.

cout << myQueue.dequeue() << myQueue.dequeue();
|       |               |    |               |
|       |____ tmp1 _____|    |_____ tmp2 ____|
|                       |
|________ tmp3 _________|
CB Bailey
  • 648,528
  • 94
  • 608
  • 638
  • so, in the top example, would std::ostream& tmp3 = cout << tmp1; tmp3 << tmp2; be like saying "cout << tmp1 << tmp2;"? Or something I'm missing? – finiteloop Jan 24 '10 at 22:57
  • @segfault: Yes, because that is the way `< – CB Bailey Jan 24 '10 at 23:03
  • but by that logic, wouldnt saying cout << a << b be saying (cout << a) << b and do anything necessary to cout a first (i.e. call myQueue.dequeue())? – finiteloop Jan 24 '10 at 23:07
  • 6
    The associativity doesn't say anything about the order in which the subexpressions are evaluated. `cout << a << b` always means `(cout << a) << b` but the compiler is free to evaluate `b` first, then `a`, then the first `< – CB Bailey Jan 24 '10 at 23:11
  • Sorry to comment on an old post, but C++11 1.9/15 (C++03 1.9/17) seems to imply that the sequencing constraints on overloaded operators are different. If my understanding is correct, the above is either `cout.operator< – jogojapan Mar 01 '13 at 04:33
  • @jogojapan: This particular fact hasn't changed in C++11 although the concept of _sequence point_ has been replaced. In neither of the expressions that you've shown is there a constraint between the evaluation of `a` and `b`. Either may be evaluated before the other. There are other constraints, such as `b` must be evaluated before either `operator< – CB Bailey Mar 01 '13 at 07:29
8

The call from your example:

cout << myQueue.dequeue() << myQueue.dequeue();

translates to the following expression with two calls of operator<< function:

operator<<( operator<<( cout, myQueue.dequeue() ), myQueue.dequeue() );
-------------------- 1
---------2

The order of evaluation of cout, myQueue.dequeue() is unspecified. However, the order of operator<< function calls is well specified, as marked with 1 and 2

mloskot
  • 33,165
  • 10
  • 97
  • 122
4

Since C++17 the behaviour of this code has changed; the left operand of << is sequenced before the right operand of <<, even when it is an overloaded operator. The output must now be ab.

For further reading see: What are the evaluation order guarantees introduced by C++17?.

M.M
  • 130,300
  • 18
  • 171
  • 314