Unexpected order of evaluation (compiler bug?) [duplicate]

by

There is a sequence point between evaluating arguments and calling a function. There is no sequence point between evaluating different arguments.

Let’s look at the outermost function call:

operator<<(operator<<(operator<<(std::cout, n++), n), ++n)

The arguments are

  • operator<<(operator<<(std::cout, n++), n)

and

  • ++n

It is unspecified which of these is evaluated first. It’s also allowed that the first argument is partially evaluated when the second argument is evaluated.

From the standard, section [intro.execution] (wording from draft 3225):

  • If A is not sequenced before
    B and B is not sequenced before A, then A and B are unsequenced. [ Note: The execution of unsequenced
    evaluations can overlap. — end note ]

  • Except where noted, evaluations of operands of individual operators and of subexpressions of individual
    expressions are unsequenced. [ Note: In an expression that is evaluated more than once during the execution
    of a program, unsequenced and indeterminately sequenced evaluations of its subexpressions need not be
    performed consistently in different evaluations. — end note ] The value computations of the operands of an
    operator are sequenced before the value computation of the result of the operator. If a side effect on a scalar
    object is unsequenced relative to either another side effect on the same scalar object or a value computation
    using the value of the same scalar object, the behavior is undefined.

Because you have multiple operations with side effects on the same scalar object which are unsequenced with respect to each other, you’re in that realm of undefined behavior, and even 999 would be a permissible output.

More Related Contents:

  1. How to create a static library with g++?
  2. Order of evaluation of elements in list-initialization
  3. Update GCC on OSX
  4. Why include guards?
  5. Template instantiation details of GCC and MS compilers
  6. Fun with uninitialized variables and compiler (GCC)
  7. How to get rid of `deprecated conversion from string constant to ‘char*’` warnings in GCC?
  8. Dual emission of constructor symbols
  9. when g++ static link pthread, cause Segmentation fault, why?
  10. Are function static variables thread-safe in GCC?
  11. gcc/g++: “No such file or directory”
  12. Array with size 0 [duplicate]
  13. Template within template: why “`>>’ should be `> >’ within a nested template argument list”
  14. Is std::string ref-counted in GCC 4.x / C++11?
  15. C++: When (and how) are C++ Global Static Constructors Called?
  16. Precompiled headers with GCC
  17. What is the difference between MinGW, MinGW-w64 and MinGW-builds?
  18. Compiling with -static-libgcc -static-libstdc++ still results in dynamic dependency on libc.so
  19. std::put_time implementation status in GCC?
  20. Overloaded lambdas in C++ and differences between clang and gcc
  21. GNU C++ how to check when -std=c++0x is in effect?
  22. Does a c/c++ compiler optimize constant divisions by power-of-two value into shifts?
  23. Which types on a 64-bit computer are naturally atomic in gnu C and gnu C++? — meaning they have atomic reads, and atomic writes
  24. Who defines C operator precedence and associativity?
  25. Does the restrict keyword provide significant benefits in gcc/g++?
  26. std::thread error (thread not member of std)
  27. Default libraries linked in by gcc?
  28. Multiple “could not be resolved” problems using Eclipse with minGW
  29. const auto std::initializer_list difference between Clang and GCC
  30. Undefined reference to process(std::__cxx11::basic_string … ) when compiling affdex linux sample applications

Leave a Comment