cout << order of call to functions it prints?

cout example
cout
cout definition
cout endl
cout format
cout c
cout include
cout meaning

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?

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 _________|

Basic Input/Output - C++ Tutorials, Standard output (cout). On most program environments, the standard output by default is the screen, and the C++ stream object defined to access it is cout . By default, cout is synchronized with stdout (see ios_base::sync_with_stdio). A program should not mix output operations on cout with output operations on wcout (or with other wide-oriented output operations on stdout ): Once an output operation has been performed on either, the standard output stream acquires an orientation (either narrow or

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

std::cout, std::wcout, The global objects std::cout and std::wcout control output to a stream buffer of implementation-defined type (derived from std::streambuf), associated with the� coût translation in French - English Reverso dictionary, see also 'coûter',coût, assurance, fret',court',cou', examples, definition, conjugation

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?.

C++ cout - C++ Standard Library, The cout object in C++ is an object of class ostream. It is used to display the output to the standard output device i.e. monitor. It is associated with the standard C output stream stdout. The global objects std::cout and std::wcout control output to a stream buffer of implementation-defined type (derived from std::streambuf), associated with the standard C output stream stdout.

C++ Syntax: Input/Output: << >>, cout The standard output, normally the screen. cerr The error output, normally the screen. I/O can be achieved just by using the appropriate function defined in the� What cout does not do automatically is add line breaks at the end, unless instructed to do so. For example, take the following two statements inserting into cout: cout << "This is a sentence."; cout << "This is another sentence."; The output would be in a single line, without any line breaks in between. Something like:

1.5 — Introduction to iostream: cout, cin, and endl, cout stands for “character output”. As a reminder, here's our Hello world program: 1. 2. 3. cout << hex << my_int << endl; hex and endl are manipulators, that result in special functions being called when they are processed:- hex changes the state of the stream so that following integers, my_int in this case, are printed in hexadecimal. As you might expect, there are also dec and oct manipulators.

'printf' vs. 'cout' in C++, I'm surprised that everyone in this question claims that std::cout is way better than printf , even if the question just asked for differences. Now, there is a difference� Cout : Display Output to User Using Screen(Monitor) In C++ Insertion operator is used to display value to the user. The value may be some message in the form of string or variable.

Comments
  • where did all of the answers go? now there is only one?
  • The answerers deleted them because they realised they were wrong.
  • Some people delete answers when they find out they are wrong.
  • so, in the top example, would std::ostream& tmp3 = cout << tmp1; tmp3 << tmp2; be like saying "cout << tmp1 << tmp2;"? Or something I'm missing?
  • @segfault: Yes, because that is the way << associates in C++ grammar. a << b << c always groups as (a << b) << c.
  • 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())?
  • 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 << operation and the the second. This is exactly the point that I made in my answer.
  • 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<<(a).operator<<(b), or operator<<(operator<<(cout,a),b) depending on whether the operator is a member or free function. Both would imply a defined evaluation order for subexpressions a and b. Is that correct?