Is preincrementing the same variable twice valid c++?

[Eric Lilja]

...or does it violate the rule that a variable may not be modified more
than once between two sequence points?

int n = 0;
std::cout << ++n << ' ' << n << ' ' << ++n << std::endl;

- Eric

[Gianni Mariani]

Eric Lilja wrote:

..or does it violate the rule that a variable may not be modified more
than once between two sequence points?

int n = 0;
std::cout << ++n << ' ' << n << ' ' << ++n << std::endl;

It's undefined.

[Pete Becker]

Eric Lilja wrote:

..or does it violate the rule that a variable may not be modified more
than once between two sequence points?

There's a sequence point before each function call (i.e. before each <<
function), so that rule doesn't apply. But the order of evaluation of
arguments is unspecified, so you can't count on any particular order for
the various values of n.

int n = 0;
std::cout << ++n << ' ' << n << ' ' << ++n << std::endl;

- Eric

--

-- Pete
Roundhouse Consulting, Ltd. (www.versatilecoding.com)
Author of "The Standard C++ Library Extensions: a Tutorial and
Reference." (www.petebecker.com/tr1book)

[=?iso-8859-1?q?Erik_Wikstr=F6m?=]

On Mar 1, 1:30 pm, Pete Becker <[e-mail]:

Eric Lilja wrote:

..or does it violate the rule that a variable may not be modified more
than once between two sequence points?

There's a sequence point before each function call (i.e. before each <<
function), so that rule doesn't apply. But the order of evaluation of
arguments is unspecified, so you can't count on any particular order for
the various values of n.

That's not true

int n = 0;
std::cout << ++n << ' ' << n << ' ' << ++n << std::endl;

^^^^^^^^^^^^^^^^^
This has to execute before the << ' ' can, otherwise there won't be a
ostream as first parameter to the << ' '-call.

--
Erik Wikström
--
Erik Wikström

[Alf P. Steinbach]

* Erik Wikström:

On Mar 1, 1:30 pm, Pete Becker <[e-mail]:

>Eric Lilja wrote:

>>..or does it violate the rule that a variable may not be modified more
than once between two sequence points?

There's a sequence point before each function call (i.e. before each <<
function), so that rule doesn't apply. But the order of evaluation of
arguments is unspecified, so you can't count on any particular order for
the various values of n.

That's not true

What isn't true?

>>int n = 0;
std::cout << ++n << ' ' << n << ' ' << ++n << std::endl;

^^^^^^^^^^^^^^^^^
This has to execute before the << ' ' can, otherwise there won't be a
ostream as first parameter to the << ' '-call.

Arguments can be evaluated before anything else happens.

--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?

[Pete Becker]

Erik Wikström wrote:

On Mar 1, 1:30 pm, Pete Becker <[e-mail]:

>Eric Lilja wrote:

>>..or does it violate the rule that a variable may not be modified more
than once between two sequence points?

There's a sequence point before each function call (i.e. before each <<
function), so that rule doesn't apply. But the order of evaluation of
arguments is unspecified, so you can't count on any particular order for
the various values of n.

That's not true

>>int n = 0;
std::cout << ++n << ' ' << n << ' ' << ++n << std::endl;

^^^^^^^^^^^^^^^^^
This has to execute before the << ' ' can, otherwise there won't be a
ostream as first parameter to the << ' '-call.

The order of the calls to operator << is well defined, but the order of
evaluation of the arguments is unspecified. The compiler can compute the
value of the first ++n, then the n, then the final ++n. It can also do
them in reverse order, or any other order.

--

-- Pete
Roundhouse Consulting, Ltd. (www.versatilecoding.com)
Author of "The Standard C++ Library Extensions: a Tutorial and
Reference." (www.petebecker.com/tr1book)

[Ron Natalie]

Pete Becker wrote:

Eric Lilja wrote:

>..or does it violate the rule that a variable may not be modified more
than once between two sequence points?

There's a sequence point before each function call (i.e. before each <<
function), so that rule doesn't apply. But the order of evaluation of
arguments is unspecified, so you can't count on any particular order for
the various values of n.

That rule does apply. Since the function parameters may be evaluated
in any order, both ++n subexpressions may be executed before ANY
function call occurs. Hence you will have the undefined behavior or
twice modifying a value between sequence points. The rule requires
that be true for ANY ALLOWABLE ORDERING of the expression.

[Ron Natalie]

Erik Wikström wrote:

On Mar 1, 1:30 pm, Pete Becker <[e-mail]:

>Eric Lilja wrote:

>>..or does it violate the rule that a variable may not be modified more
than once between two sequence points?

There's a sequence point before each function call (i.e. before each <<
function), so that rule doesn't apply. But the order of evaluation of
arguments is unspecified, so you can't count on any particular order for
the various values of n.

That's not true

Partially true.

>

>>int n = 0;
std::cout << ++n << ' ' << n << ' ' << ++n << std::endl;

^^^^^^^^^^^^^^^^^
This has to execute before the << ' ' can, otherwise there won't be a
ostream as first parameter to the << ' '-call.

The real issue is that the compiler is free to execute both ++n
subexpressions in any order and at any time prior to the call
of the operator<< where they are parameters. Specifically it
can execute them BOTH before either operator << call ,causing
undefined behavior.