++++i;

[Mr Flibble]

Hi,

Is the following undefined behaviour?

int i = 0;
++++i;

Here i is modified twice in the same expression so I think it is UB but
I'm not 100% sure.

/Flibble

[Mr Flibble]

Some are saying that it is possibly UB in C++03 but fine in C++11.
Mystified.

/Flibble

[Chris Vine]

As am I. But whatever, just use the comma operator (++i, ++i), which is
always right.

Chris

[Scott Lurndal]

I guess I don't see why either alternative is superior to i += 2

[Mr Flibble]

If 'i' is a bi-directional (not random access) iterator the += 2 won't work.

/Flibble

[Mr Flibble]

However for such an iterator operator++ is a function call so there
won't be the possibility of UB.

/Flibble

[Martijn Lievaart]

Does this also hold if the iterator is implemented as a pointer?

M4

[Chris Vine]

Interesting, on looking further at this, I think that although illegal
in C++98, the expression ++++i is valid in C++11/14.

The complete normative reading of §1.9/15 of C++11, with examples and
parenthetical comments removed, is:

"Except where noted, evaluations of operands of individual operators
and of subexpressions of individual expressions are unsequenced. 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."

It is the second sentence which is important. ++++i is in effect
identical in C++11 to ++i,++i. Likewise although the behaviour of this
is unspecified in C++98, I think it is required to increment by 2 in
C++11:

i = ++i + 1

However, this is still undefined in C++98 and C++11:

i = i++ + 1

Turning to the examples given in the standard, the reason why in C++11
this:

i = v[i++];

is undefined is that although the assignment to i is sequenced before
the evaluation of v[i] on the right hand side, the subsequent side
effect comprising the increment of i carried out on the right hand side
is not. So the increment of i on the right hand side and the assignment
to i are unsequenced. On the other hand this:

v[++i] = ++i;

is invalid in C++11 (I think) because, although the assignment is
sequenced before the evaluation of the right hand side, the
prior evaluation of the subexpression ++i on the left hand side is
unsequenced with respect to the evaluation of ++i on the right hand
side.

Err, I think.

Chris

[Chris Vine]

On Wed, 3 Dec 2014 11:28:40 +0000

^^^^^^
after

[Martijn Lievaart]

All this says to me is that the value of ++i must be known, not that the
side effects have taken place. AFAICS the value of ++i must be of
reference type, not value type, so can be known without the side effect
taking effect.

But that is also just my interpretation. Bottomline, don't do this. ++i; +
+i; has the same effect and is clearer.

M4

M4

[Chris Vine]

Pre-increment on a scalar is required by the standard to have completed
its side effects by the time its value is known. That is the reason
why the construction appears to be valid. Its value with respect to a
scalar is stated to be a lvalue (§5.3.2/1). Its side effect is, by
rule, to increment the scalar and its value is its value after the
increment. On a user defined type the effect is whatever the user
provides it to be, and because pre- and post-increment are function
calls on user and library types, different sequencing considerations
apply - the return of a function call is always sequenced after
evaluation of the arguments and the evaluation of any side effects
within the body of the function.

On a sub-note, it is interesting to compare the examples given in §5/4
of C++98 and §1.9/15 of C++11. In C++98 pre-increment 'i = ++i + 1' is
given as an example of unspecified behaviour (which by virtue of the
last sentence of §5/4 is also undefined behaviour). In C++11 it is not:
instead the examples substitute the post-increment 'i = i++ + 1' as an
example of undefined behaviour.

> But that is also just my interpretation. Bottomline, don't do this.

> ++i; ++i; has the same effect and is clearer.

I agree. This is for pedagogical purposes only. I hope it would never
be in live code.

Chris

[Martijn Lievaart]

Yeah, ++++i feels like some other unspecified computer language. :-)

M4

[Jack Chuge]

Martin, I agree with you, lol

--
Jack