9

I came across this problem in this website, and tried it in Eclipse but couldn't understand how exactly they are evaluated. 

    int x = 3, y = 7, z = 4;

    x += x++ * x++ * x++;  // gives x = 63
    System.out.println(x);

    y = y * y++;
    System.out.println(y); // gives y = 49

    z = z++ + z;
    System.out.println(z);  // gives z = 9

According to a comment in the website, x += x++ * x++ * x++ resolves to x = x+((x+2)*(x+1)*x) which turns out to be true. I think I am missing something about this operator precedence.

Ashok Bijoy Debnath
  • 1,493
  • 1
  • 17
  • 27

6 Answers6

13

Java evaluates expressions left to right & according to their precedence.

int x = 3, y = 7, z = 4;

x (3) += x++ (3) * x++ (4) * x++ (5);  // gives x = 63
System.out.println(x);

y = y (7) * y++ (7);
System.out.println(y); // gives y = 49

z = z++ (4) + z (5);
System.out.println(z);  // gives z = 9

Postfix increment operator only increments the variable after the variable is used/returned. All seems correct.

This is pseudocode for the postfix increment operator:

int x = 5;
int temp = x;
x += 1;
return temp;

From JLS 15.14.2 (reference):

The value of the postfix increment expression is the value of the variable before the new value is stored.

jn1kk
  • 5,012
  • 2
  • 45
  • 72
  • 1
    Thanks for that last statement :) makes it easy to understand how ++x is evaluated. Always got confused with ++x prior to this example. – WilliamShatner Nov 13 '12 at 21:55
  • 'Java evaluates expressions left to right according to their precedence' is a contradiction in terms. Java evaluates *operands* left to right; *operators* are evaluated in the order dictated by operator precedence and associativity. – user207421 Nov 13 '12 at 22:39
5

Nothing to do with operator precedence per se, just the order of evaluation. Two things to know here:

  1. x++ is the postfix increment, so the value of x is incremented after it is evaluated
  2. * evaluates the right side then the left side.

Considering point 2, the expression x++ * x++ * x++ can be rewritten more specifically as x++ * (x++ * (x++)).

The whole expression can be written as the procedures:

a = x
x += 1
b = x
x += 1
c = a*b
d = x
x += 1
return c*d
Tim Bender
  • 20,112
  • 2
  • 49
  • 58
  • +1, but with nitpick: Actually, operator precedence is in effect everywhere, where you have more than one operator in an expression or statement:) prefix and postfix operators have higher priority than binary operators, and this is why `x++ * x++` can be written **without parentheses**. You'd have to write `(x++) * (x++)`. Without operator precedence and parens, only right-to-left would take place, and it _could_ mean `x ++ * (x++))` which for example could be a syntax error: no LHS operand for * – quetzalcoatl Nov 13 '12 at 22:23
  • Okay, fair enough. I simply meant that the answer would have more to do with the behaviors of postfix and prefix operators as opposed to operator precedence as would be the case with an expression that mixed many operators of different precedence (eg. `x++ * x++ + x++ / x++`) – Tim Bender Nov 13 '12 at 22:45
2

The postfix operator x++ means something like "give me the value of x now, but increment it for future references"

So, by the order of operations and evaluation,

x++ * x++ * x++

is interpreted first as

3 * 4 * 5 (=60)

Which is then added to the original 3, yielding 63.

The original value is used because it's on the same line, had you written something like:

int x = 3;

int y += x++ * x++ * x++; 
x += y;

x would now be 66, instead of 63 because the x in the second line is now 6, rather than its original 3.

jedwards
  • 29,432
  • 3
  • 65
  • 92
2

Because the increment Operation ++ is added after the variable x. That's a post increment operation. That means, x is incremented after the operation is handled. 

In your example the expression would be: 
x += 3 * 4 * 5
First the expression is added by 3 (x+=....)
then the first x++ results in 3
the second x++ results in 4 (because it was incremented before)
and the third x++ results in 5.

If you want your variable incremented before the operation is executed, you have to write ++x (pre increment operation)

Fabian Trottmann
  • 214
  • 4
  • 12
1

Because a postincrement modifies the variable after the value is taken and += evaluates its left hand side before evaluating its right hand side,

x += x++ * x++ * x++;

becomes

tmp0 = x

tmp1 = x
++x
tmp2 = tmp1 * x
++x
tmp3 = tmp2 * x
++x

x = tmp0 + x
Dan
  • 12,409
  • 3
  • 50
  • 87
  • Are you sure yo meant the left hand side gets evaluated BEFORE the right hand side, because I think I knew the opposite ? The code breakup is good, except that the last statement x = tmp0 + x doesn't result in 63 for x = 3. – Ashok Bijoy Debnath Nov 13 '12 at 22:03
  • Otherwise it would be 66 instead of 63. – Dan Nov 13 '12 at 22:04
1

unary operators evaluated left to right, so the first x++ gets the value x, the second is (x+1), etc. And the += evaluates according to the value of x at the start, hence the addition of x

Kevin Welker
  • 7,719
  • 1
  • 40
  • 56