Post increment and the assignment operator

[Carol Murphy]

Here's a code snippet from a mock SCJP exam question:
int i = 100 ;
i = i++ ;
i = ++i ;
i = i-- ;
i = i++ ;
System.out.println( i ) ;
the value of i that gets printed out is 101, much to my surprise. It took me forever to understand the explanation, because they could have said that the assignment operator has precedence over post-increment/post-decrement, therfore the value stored in i doesn't change. Instead, they gave some arcane reason that I didn't understand. Now that I get it, my question is this: What happens to the increment/decrement that occurs after assignment? Does it happen and then disappear into the ether after the statement executes, or does it not happen at all?

[Stan James]

Does it happen and then disappear into the ether after the statement executes

Yup, that's about it. You know you can call a method that returns a value without using the value. This is valid code:

myString.toUpperCase();

The toUpperCase method returns a new String value. I'd guess it goes on the heap, but I make a point of not caring. Since it is never assigned into a variable, it is unreferenced and a candidate for garbage collection.
BTW: because the example you gave is confusing and an easy opportunity to make a mistake, some teams have coding standards that only allow these operators on lines by themselves.

a = b;
b++;
 
// and not
a = b++;

[Charles Keller]

To Carol Murphy,
I had trouble myself with the postfix notation, which in i=i++, did not do anything, except if you have a=2;b=a++ the result is a=2 and b=3.
So, I created the attached IncDecrementTrial4.java file, together with the output in Word. Please let me know what you think.

// File C:\java-CK -IncDecrementTrial4.java    (*.java and *.class files)
// Source: Ch. Keller - with i only (no value2)
// Febr. 26,04
// Output:  fine, see attached sheet
//          Output is different for:  int i = 100, value2 = 100; or
//                                    a=100; b=a++    result: a=100;b=101
//                                                    1) 'a' stays at 100
 //                                                   2) 'b' goes to 101
//--------------------------------------------------------------------------
class IncDecrementTrial4
  {
   public static void main (String [] args)
     {
       int i = 100;   // basic initial value of 100
       System.out.println("0-basic value of i is 100 = " + i);
       i = i++; //1-postfix increment of i: adds 1 after statement
                // i does not change, stays at 100
       System.out.print("1- i after postfix increment i++ should be 100: ");
       System.out.println( + i);
                 // #2 - does not change fom #1
       System.out.print("2-repeat of 1: ");
       System.out.println("i after postfix increment i++ should be 100: " +i);
       i = ++i; //3-prefix increment of i, change will occur immediately
                //  and i changes from 100 to 101 (due to ++1 prefix)
       System.out.print("3- i after prefix increment ++1 should be 101: ");
       System.out.println( +i);
       i = i--; //4-postfix decrement of i: deducts 1 after statement
                // i does not change, stays at 101
       System.out.print("4- i after postfix decrement i++  should be 101: ");
       System.out.println( + i);
       i = i++;  //5-postfix increment of i: adds 1 after statement
                      // i does not change, stays at 101
       System.out.print("5- i after last postfix increment i++ should be ");
       System.out.println("101: "  + i);
       System.out.println();
     }
  }
  // Using i = ++1, will not give you a second value = value2
  //                  therefore, the output will be different

  

 
Output-IncDecrementTrial4-with i only-Feb.26,04
Feb.26,04 
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
C:\j2sdk1.4.2_02\bin\java.exe  -classpath "C:\j2sdk1.4.2_02\jre\lib\rt.jar;C:\j2sdk1.4.2_02\lib\tools.jar;C:\java-CK" IncDecrementTrial4 Float.parseFloat(args[0];
0-basic value of i is 100 = 100
1- i after postfix increment i++ should be 100: 100
2-repeat of 1: i after postfix increment i++ should be 100: 100
3- i after prefix increment ++1 should be 101: 101
4- i after postfix decrement i++  should be 101: 101
5- i after last postfix increment i++ should be 101: 101
Finished executing
 

[Davy Kelly]

Carol,
int i = 100
i = i++;
i++ does happen but only when the whole statement has finished.
it is like saying i = i; then increment the i that had the ++ operator, so you assigned i to 100;
the method that i understood it with was this:

  
int i = 0;
i = i++ + i++ + ++i + ++i + i++;
breakdown
i=
i++    0  //then add 1
+      +
i++    1  //then add 1
+      +
++i    3  //you had 2, now you pre increment to get 3
+      +
++i    4  // you had 3, now pre increment to get 4
+      +
i++    4  //you had 4, this is post increment but only do afteronly do after 
//but there is no after... i should be 5 here, but i can't increment it now, so the incrementation is lost.
so i = 0+1+3+4+4  which is i = 12

Does this help you, it would be the same with the -- operator.
I know it is not what you really asked but it shows you how the post and pre-incrementer work.
so you can add your code to it.
int i = 100 ;
i = i++ ; //i = 100 the post-increment did not get done (effectively)
i = ++i ; //i = 101 the pre-increment did
i = i-- ; //i = 101 the post-decrement did not get done (effectively)
i = i++ ; //i = 101 the post-increment did not get done (effectively)
System.out.println( i ) ; //i = 101
Davy
[ February 27, 2004: Message edited by: Davy Kelly ]

[sever oon]

The way I look at these pre/post increment/decrement operators is as follows. When you perform one of these, think of the compiler creating a new variable and: (a) copying the value, and (b) running the increment/decrement operation. The order of (a) and (b) changes depending on whether it's a post or pre operation.
So:

int i = 5;
i = i++;

...would be equivalent to...

int i = 5;
{
  int j = i;
  i = j; // copies the value into j
  j = j + 1; // THEN runs the operation (postincrements)
}
// i==5 at this point

(I only included the {}'s to show that the temporary variable j goes immediately out of scope and doesn't exist outside the expansion that the compiler introduced...that's why you can't get at that temporary value and it just gets dropped out of existence.)
Now let's look at the expanded version of preincrement:

int i = 10;
i = ++i;

...is equivalent to...

int i = 10;
{
  int j = i;
  j = j + 1; // runs the operation (preincrements)
  i = j; // THEN copies the value
}
// i==11 at this point

If you always do those expansions in your head whenever you see the code, you can always figure out what's going on even in complicated operations like:

int i = 1;
int k = i++ + i++ + ++i + i++;

This looks really daunting at first, but if you know that the + operator is left associative (i.e. this statement will evaluate first at the rightmost +, and continue to crawl to the left), you can break it down step by step. And in this case, you see the effect of the temporary variable int this case because when it's returned, it doesn't simply go out of scope before getting used--it is that temporary variable that's used in place of the evaluated operand.
So you should be able to see with a little consideration how the above code expands to:

int x = 1;
int k;
{
  int temp1 = ++x + x++;
  int temp2 = x++ + temp1;
  int temp3 = x++ + temp2;
  k = temp3;
}

Now you can easily expand the expressions for temp2 and temp3 as the rule above shows (we'll deal with temp1 after):

int x = 1;
int k;
{
  int temp1 = ++x + x++; // work on this later--do the easy parts first
  // expanded: int temp2 = x++ + temp1;
  int temp2;
  {
    int j = x;
    x = x + 1;
    temp2 = j + temp1;
  }
  // expanded: int temp3 = x++ + temp2;
  int temp3;
  {
    int j = x;
    x = x + 1;
    temp3 = j + temp2;
  }
  k = temp3;
}

Now we have everything expanded except that first line, which I left till now because it has two of these little increment nasties. But it's not that bad, actually...you just make sure you expand the right most operand before the left:

// expanded: int temp1 = ++x + x++;
int temp1;
{
  // expand the x++ first...
  int j1 = x;
  x = x + 1;
  
  // now expand the ++x...
  x = x + 1;
  int j2 = x;
  temp1 = j2 + j1;
}

Now if we put this whole mess together, this:

int i = 1;
int k = i++ + i++ + ++i + i++;

expands to this:

int x = 1;
int k;
{
  // expanded: int temp1 = ++x + x++;
  int temp1;
  {
    int j1 = x; // post
    x = x + 1;
  
    x = x + 1; // pre
    int j2 = x;
    temp1 = j2 + j1;
  }
  // expanded: int temp2 = x++ + temp1;
  int temp2;
  {
    int j = x; // post
    x = x + 1;
    temp2 = j + temp1;
  }
  // expanded: int temp3 = x++ + temp2;
  int temp3;
  {
    int j = x; // post
    x = x + 1;
    temp3 = j + temp2;
  }
  k = temp3;
}

And now a final runthrough to see what x and k end up as. I'll put a comment after each line whenever a value changes:

int x = 1; // x=1
int k; // k=0
{
  int temp1; // temp1=0
  {
    int j1 = x; // j1=1
    x = x + 1; // x=2
    x = x + 1; // x=3
    int j2 = x; // j2=3
    temp1 = j2 + j1; // temp1 = 3+1 = 4
  }
  int temp2; // temp2=0
  {
    int j = x; // j=3
    x = x + 1; // x=4
    temp2 = j + temp1; // temp2 = 3+4 = 7
  }
  int temp3; // temp3=0
  {
    int j = x; // j=4
    x = x + 1; // x=5
    temp3 = j + temp2; // temp3 = 4+7 = 11
  }
  k = temp3; // k=11
}
// k == 11
// x == 5

Fascinating, no? (Well, maybe not.)
sev
[ February 29, 2004: Message edited by: sever oon ]