...

The "after the current statement" model works for some cases, but fails
to explain why

public class YuckyTest {
  public static void main(String[] args) {
    int a = 1;
    int b = a++ + a++;
    System.out.println(b);
  }
}

prints 3, not 2.

In the JLS they are called "postfix increment operator" and "prefix
increment operator", making the "post" or "pre" refer to the syntax, not
the functionality.

Patricia

Thanks for the replies.
I would never use code like i=i++; but was curious to see what
happened. I'll look at the link you posted Patricia and if I have any
other questions I'll come back to you
Thanks again

Lookahead algorithms.  Sometimes it's convenient to know both i and i+1
without having to repeat the addition all the time.

In any case an idiom like this would be part of a very local block.

På Mon, 09 Apr 2007 18:37:31 +0200, skrev Luc The Perverse  
<sll_noSpamlicious_z_XXX_m@cc.usu.edu>:

Well, it can be useful in C/C++ which don't define the consequence of that  
statement. :)

int main(int argc, char** argv) {
  int i = 1;
  i = i++;
  if (i != 1) {
    printf("I disagre with what the compiler has done with me and will  
terminate.\n");
    printf("Plese recompile me with a compiler that is not like totally  
WRONG.\n");
    exit(0);
  }
  else {
    /* Do something useful */
  }
}

That is not true.  Obviously, if it were true, then the given output
would be different.  If the assignment happened first (setting i to 1)
and then the increment (setting i to 2), then the second line of output
would read "2".  It doesn't, so that execution model is wrong.  I don't
know who it was that first described the behavior of post-increment in
terms of when the increment happens.  Whoever first spread that
misunderstanding about Java should be ashamed of themselves.

What really happens is that the expression is evaluated whenever the
evaluator gets to it.  Nothing is delayed or put off.  The evaluation
has a side-effect (incrementing the variable) and a result (the value of
the variable before the increment).  Both the side effect and the
evaluation itself are fully performed at that point.  Then the execution
goes on to process other subexpressions.

So you start out with the following:

          =
         / \
        i  post-++
             \
              i

First, the left hand side of the assignment is evaluated, obtaining the
location of the variable i.  Let's say it's memory address 123, which
I'll write as M[123].  There is no side-effect.  So,

          =
         / \
   M[123]  post-++
             \
              i

Next, the right-hand side of the assignment is evaluated.  The right-
hand side of the assignment is a post-increment, so the first step is to
evaluate the variable to an lvalue.  It's the same variable, so:

          =
         / \
   M[123]  post-++
             \
             M[123]

Now that the operand to the post-increment has been evaluated, the post-
increment itself is evaluated.  This has two effects.  It reads the
value of M[123], and gets 1.  That is the result of the expression.  
Also, right now (NOT delayed) it increments the value in that memory
location as a side-effect.  It does not increment the result of the
expression; that's still 1.

          =
         / \
   M[123]   1

   (as a side effect, now M[123] == 2)

Finally, the '=' operator has had both of its operands evaluated, so the
operator itself gets evaluated.  This again does two things.  First of
all, the result of the expression is the same as the right-hand side,
which is 1.  Second, the value of the RHS is stored into the memory
location described by the LHS as a side effect.  So,

          1

   (as a side effect, now M[123] == 1)

So as you can see, the value of i did briefly get assigned to 2, but was
then overwritten by 1 again, explaining the fact that nothing appears to
have changed.  The order of those two writes to i -- the post-increment,
and then the assignment -- is critical to understanding what happens
here, and it's certainly wrong to say that the increment happens at some
later time.  As you can plainly see, the increment happened in exactly
the same evaluation step as when the value of that subexpression was
decided.  It wasn't delayed in the slightest.

(As a side note, none of this applies to C or C++, despite the fact that
they have operators that look identical.  Both of those languages allow
considerably greater flexibility to their implementations in terms of
the result of expressions like this.  We're just talking Java here.)