CODEWITHSUNDEEP
c++undefined-behavior
user825156
user825156

Reputation: 23

Undefined behaviour of sub-expressions

Does this result in undefined behaviour because the order of evaluation will be unspecified?

int i = 0, j = 0, k = 0;
int result = i++ + ++j + k++;

Upvotes: 2

Views: 142

Answers (8)

Loki Astari
Loki Astari

Reputation: 264631

Here:

int result = i++ + ++j + k++;

Is Equivalent too:

<SP>
(a1)int t1 = i;     // i++ part one: The result of post-increment is the original value
(a2)     i = i + 1; // i++ part two: the increment part separated from the result
(b1)     j = j + 1;
(b2)int t2 = j;     // The result of pre-increment is the new value
(c1)int t3 = k;     // k++ part one: The result of post-increment is the original value
(c2)     k = k + 1;
(d) int t4 = t1 + t2;
(e) int t5 = t3 + t4;    
(f) int result = t5;
<SP>

The constraints are:

(a1) is before (a2)
(a1) is before (d)
(b1) is before (b2)
(b2) is before (d) 
(c1) is before (c2)
(c1) is before (e)
(d)  is before (e)
(e)  is before (f)

As long as the above constraints are maintained the instructions can be re-ordered as much as the compiler likes. But the constraints guarantee that the result is well formed.

Upvotes: 0

CB Bailey
CB Bailey

Reputation: 792777

No, the result of the evaluation doesn't depend on the unspecified order of evaluation of the sub-expressions.

Undefined behavior only occurs in this situation if two side effects that affect the same object are unsequenced relative to each other or a side effect and a value computation of the same object are unsequenced. The side-effect and value computation of both prefix and postfix increment are explicitly sequenced.

Upvotes: 5

RoundPi
RoundPi

Reputation: 5947

No, it's a classic/well known c++ sequence point issue, see link here for much more detail http://en.wikipedia.org/wiki/Sequence_point

Upvotes: 0

Mark Ransom
Mark Ransom

Reputation: 308452

The rule is that the results are unspecified if you modify a variable more than once. You haven't done that in your example.

Upvotes: 1

Diego Sevilla
Diego Sevilla

Reputation: 29021

Here result will be always 1. The values of j, k, and i will be all 1. Also, note that separator for several variable declaration is ,, and not ;:

int i=0, j=0, k=0;

Upvotes: 0

Peter Alexander
Peter Alexander

Reputation: 54290

It's fine here because you don't use the same variable twice.

What you have is equivalent to:

int i = 0, j = 0, k = 0;
++j;
int result = i + j + k;
++i;
++k;

If you were to have instead int result = i++ + ++i + i++; then you'd have a problem because the order of the increments is unspecified, and you depend on that order.

Upvotes: 0

Lightness Races in Orbit
Lightness Races in Orbit

Reputation: 385295

The order of evaluation is unspecified, but who cares? Each operand acts on a completely distinct object. Nothing undefined here.

Upvotes: 4

Fred Foo
Fred Foo

Reputation: 363777

No, the behavior is perfectly well-defined: j is incremented, then addition is performed, then i and k are incremented. The only thing that is unspecified is the order in which the increments on i and k are performed. The postcondition is i==1, j==1, k==1, result==1.

Upvotes: 1

Related Questions