correcting the cout execution

Question

While using cout if the statement is cout<<E1<<E2<<E3; then there is no guarantee that the E1 E2 and E3 will be executed in the same order they are written.

What can I do to make sure they execute in same order they are written without writing another cout statement or endl in between?

What makes you think the expressions are *not* executed in the written order? — cigien, Apr 24 '20 at 18:11
You can switch to C++17 which introduces additional rules causing them to be executed as desired. — user7860670, Apr 24 '20 at 18:12
@cigien At least before C++17 the evaluation order is undefined there. — eesiraed, Apr 24 '20 at 18:13
@BessieTheCow True, was just wondering what issue the OP has. — cigien, Apr 24 '20 at 18:13
@cigien I have written one program which has the same problem question is here https://stackoverflow.com/questions/61403626/reference-not-changing-the-value-of-variable — Mrugesh Raulji, Apr 24 '20 at 18:14
evaluate it before and store it in `D1`,`D2`,`D3`, then print that, usually order of evaluation is not really a problem — 463035818_is_not_an_ai, Apr 24 '20 at 18:14
@MrugeshRaulji Ok, please add that information to the question. — cigien, Apr 24 '20 at 18:14
@user7860670 Right now I am learning from c++ primer 5th edition. Can you tell me some book as good as C++ primer and teaches C++ 2020 or C++ 2017? — Mrugesh Raulji, Apr 24 '20 at 18:16
@MrugeshRaulji Try this [resource](https://stackoverflow.com/questions/388242/the-definitive-c-book-guide-and-list) — cigien, Apr 24 '20 at 18:17
@MrugeshRaulji you should rephrase the question to emphasize your concern about the order of evaluation and not the execution. — shargors, Apr 27 '20 at 17:23

passing_through · Answer 1 · 2020-04-24T19:41:31.400

I'm not sure if it's the best decision (or just a good one at least) but you can use Boost.Preprocessor:

#include <boost/preprocessor/seq/for_each.hpp>
#include <boost/preprocessor/variadic/to_seq.hpp>

#define COUT_IMPL(_, __, i) \
  std::cout << (i);
#define COUT(...) \
  BOOST_PP_SEQ_FOR_EACH( \
    COUT_IMPL, \
    _, \
    BOOST_PP_VARIADIC_TO_SEQ(__VA_ARGS__) \
  );

void use() {
  COUT(e1, e2, e3);
}

This makes C preprocessor create ;-terminated couts for you, providing guaranteed order of evaluation.

score 0 · Answer 2 · answered Apr 24 '20 at 19:56

0

Unless your << operator is redefined, this will execute in the order written. The

cout << E1

is executed first with a return type of std::ostream (unless of course we're playing games with a different cout type. cout is not a C++ keyword or reserved word). This side-effected cout is passed to the next expression:

cout << E2

The processing is repeated for the next argument. I'm not aware of any C++ changes to operator precedence. I can't think of any way to play with the C preprocessor or play with other really obscure overloading techniques where you might be able to do some atypical operations.

answered Apr 24 '20 at 19:56

Richard Jessop

897
1
12
19

1

As far as I know, the stream operation execution order is well-defined but the evaluation order of those `E`s is not (until a certain language standard). – passing_through Apr 25 '20 at 06:34
If not well defined, then a type analysis on the return values from intermediate operations should result in a compiler error on at least one platform. Assuming R-L ordering, E2< – Richard Jessop Apr 25 '20 at 18:59
I'm afraid you misunderstood my point: the order of writing values to a stream is well-defined but the order of computing those values (if they are written as expressions like `cause_side_effect()`) is (was?) not. – passing_through Apr 25 '20 at 19:22
The light shineth. – Richard Jessop Apr 25 '20 at 21:08

correcting the cout execution

2 Answers2