In crement-Why is 'a' jumping to 102 instead of 101?

[Charles Keller]

I have a puzzle on my hands: on Item#3 of the attached java file
the 'a' is jumping to 102 when it should be at 101. The output
file (Word) is also attached to this e-mail.
Thank you for your help.
Charles.

// File C:\java-CK -IncDecrementTrial5.java    (*.java and *.class files)
// Source: Ch. Keller - with i only (no value2)
// Febr. 27,04
// Output: see attached sheet. why is 'a' at #3 jumping from 100 to 102 ??
//          Output is different from int = i  (because here are 2 int, a & b)
//--------------------------------------------------------------------------
class IncDecrementTrial5
  {
   public static void main (String [] args)
     {
       int a=100, b=100;   // basic initial value of a=100 and b=100
       System.out.println("0- values of a & b are 100 = a:" + a + " b:" + b );
       a = b++; //1-postfix increment of b: adds 1 after statement a=b++
              // adds 1 to b after "statement" indeed
              // and a stays at 100
       System.out.print("1- b after postfix increment b++ should be 101= a:" );
       System.out.println( + a + " b:" + b);
                 // #2 - does not change fom #1
                 // a stays at 100
                 // b stays at 101
       System.out.print("2-repeat of 1: ");
       System.out.print("b after postfix increment b++ should be 101= a:" ) ;
       System.out.println( + a + " b:" + b );
       a = ++b; //3-prefix increment of b, change will occur immediately
                //  and b changes from 100 to 101 (due to ++b prefix)
                //  and a changes from 100 to 102 (why ???)
       System.out.print("3- b after prefix increment ++b should be 102= a:" );
       System.out.println(  + a + " b:" + b );
       System.out.println("Why is 'a' jumping from 100 to 102 ?? = a:" + a );
       a = b--; //4-postfix decrement of b: deducts 1 after statement
                // b changes from 102 to 101, due to "after statement" a=b--
                // and a stays at 102 (why 102 ???)
       System.out.print("4- b after postfix decrement b--  should be 101= a:");
       System.out.println( + a + " b:" + b );
       a = b++;  //5-postfix increment of b: adds 1 after statement a=b++
                      // b changes from 101 to 102, due to "after statement"
                      // a = b++
                      // and a changes from 102 to 101
       System.out.print("5- b after last postfix increment b++ should be ");
       System.out.println("102= a:"  + a + " b:" + b );
       System.out.println();
     }
  }
  

  
Output-IncDecrementTrial5-Feb.27,04 (File 586 C:\java-CK\*.*)
Why is �a� jumping from 100 to 102 and not to 101 ? 
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 

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" IncDecrementTrial5 Float.parseFloat(args[0];
0- values of a & b are 100 = a:100 b:100
1- b after postfix increment b++ should be 101= a:100 b:101
2-repeat of 1: b after postfix increment b++ should be 101= a:100 b:101
3- b after prefix increment ++b should be 102= a:102 b:102
Why is 'a' jumping from 100 to 102 ?? = a:102
4- b after postfix decrement b--  should be 101= a:102 b:101
5- b after last postfix increment b++ should be 102= a:101 b:102
Finished executing

[Howard Kushner]

       a = b++; //1-postfix increment of b: adds 1 after statement a=b++
              // adds 1 to b after "statement" indeed
              // and a stays at 100
       System.out.print("1- b after postfix increment b++ should be 101= a:" );
       System.out.println( + a + " b:" + b);
                 // #2 - does not change fom #1
                 // a stays at 100
                 // b stays at 101
       System.out.print("2-repeat of 1: ");
       System.out.print("b after postfix increment b++ should be 101= a:" ) ;
       System.out.println( + a + " b:" + b );
       a = ++b; //3-prefix increment of b, change will occur immediately
                //  and b changes from 100 to 101 (due to ++b prefix)
                //  and a changes from 100 to 102 (why ???)
       System.out.print("3- b after prefix increment ++b should be 102= a:" );
       System.out.println(  + a + " b:" + b );
       System.out.println("Why is 'a' jumping from 100 to 102 ?? = a:" + a );

Charles,
After step 1 a equals 100 and b equals 101.
But in step 3 b gets incremented to 102 before the new result is assigned to a.
Make sense?
[ February 27, 2004: Message edited by: Howard Kushner ]

[Charles Keller]

Howard,
You are right, b is at 102 and obviously a follows b at 102.
Thank you Howard, your help is very much appreciated.
Charles.

[sever oon]

One interesting thing you might want to figure out is:

int i = 1;
i += i++ + i++ + ++i + i++;
// what is i?

First, expand that nasty little += operator. Keep in mind += (like =) is right-associative, so when it is expanded the i is replaced with the value of i before any other evaluation takes place:

int i = 1;
i = 1 + i++ + i++ + ++i + i++;
// the += was expanded to: i = (i) + i++ + i++ + ++i + i++;
// and the (i) is replaced with i's current value, which is 1

(Another code snippet that you might find helpful to run is:

int[] x = new int[] { 5, 5 };
int i = 1;
x[i] = i = 0;

The result after this snippet runs? x is { 5, 0 } and i is 0.)
Because the + operator is right associative, the right operand is evaluated first. The explicitly paranthesized version of the above statement is:

int i = 1;
i = (1 + (i++ + (i++ + (++i + (i++)))));

So the expression is evaluated (steps explicitly shown):

i = 1 + i++ + i++ + ++i + i++; // i is 1
i = 1 + i++ + i++ + ++i + 1; // i is 2 because post-increment runs *after* evaluating expression
i = 1 + i++ + i++ + 3 + 1; // i is 3, pre-increment ran *before* evaluating expression
i = 1 + i++ + 3 + 3 + 1; // i is 4, post-increment runs after eval
i = 1 + 4 + 3 + 3 + 1; // i is now 5, post-increment runs after eval
i = 1 + 4 + 3 + 4; // collapse literals
i = 1 + 4 + 7; // collapse literals
i = 1 + 11; // collapse literals
i = 12; // collapse literals

Voila.
The thing to keep in mind is that with left-associative operators like = and +=, the leftmost operands are evaluated first and all expressions are replaced. With right-associative operators like +, the rightmost operands are evaluated first and all expressions replaced.
Oh yea, I couldn't leave without this little gem (language lawyers will find this delightful). The following two statements are both compilable and equivalent:

i += i++ + i++ + ++i + i++;
i+=i+++i+++ ++i+i++;

Boggles the mind, don't it?
sev
[ March 01, 2004: Message edited by: sever oon ]

[Charles Keller]

Thank you sever for your interesting posting re. += bugger. I certainly
will try it out.
I have another question re. Increment & Decrement including prefix and postfix. I tried to make a truth table and I wonder if I got it right or whether there are mistakes in it. So I sending you as attachment the following documents:

IncrementDecrement Explanation (File 586 C:\java-CK\*.*)
Study Notes - Feb.26,04
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Explanation of prefix and postfix: 
When you use a prefix notation, you perform the operation on the original value. Thus, a=2 and b=++a  results in both a  and b  being equal to 3. 
When you use a postfix notation, you perform the operation without affecting the original value of �a�. Thus, in this case,  a=2 and b=a++ results in both a being equal to 2 and b equal to 3.
Truth Table of Prefix and Postfix, Increment and Decrement: 
OperatorOperationExampleResult 
-------------                   ---------------                -------------                   ----------   
 ++ (Prefix notation)  Incrementa=2; b= ++a a=3; b=3 
 
++ (Postfix)  Increment a=2; b= a++ a=2; b=3 
                                                                                                            a will be increased in 
                                                                                                            next statement, if any. 
                                                                                                            Otherwise, it will be lost.
                                                     
- -  (Prefix notation) Decrement a=2; b= - aa=1; b=1 

- - (Postfix) Decrement a=2; b= a - a=2; b=1
                                                                                                            a will be decreased in
                                                                                                            next statement, if any
                                                                                                     Otherwise, it will be lost. 

  

File C:\java-CK\analysis of incDecrementTrial6.xls 
Mar.01,04
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 Number   -------------------------------------- Statement ----------------------------------- -------- variable ---------
      a      b 
--------------------------------------------------------------------------------------------------------------------------------------------------
#0  Initializing:  a  and  b 1050
#1 a=b++ (Postfix Increment Notation )5051
            you perform the operation without affecting the 
            original value of 50 in 'b', but you increase 'b' by 1 
#2Repeat of #1, no statement 5051
#2-AAssignment only a=b, no statement 5151
#3a=++b  (Prefix Increment Notation) 5252
            you perfom the operation on the original value of 51 in 'a',
            and the results in both a and b to be increased by 1
#4a=b- -  (Postfix Decrement Notation) 5251
           you perform the operation without affecting the original value
           of 52 in 'a' , but you decrease 'b' by 1
#5a=b++ (Postfix Increment Notation) 5252
           1) first deduct 1 from previous #4 Postfix decrement in 'a') 51
           2) you perform the operation without affecting the 
               corrected  value of 51 in ''a',  but you increase 'b' by 1  
           3) It is only in the next statement, that 'a' gets incremented 
              by 1. It there is no next statement, it is lost. 

Truth Table of prefix and postfix notations: 
When you use a prefix notation, you perform the operation on the original values of both 'a' and 'b'.
Thus, a=51 and b=51 result in both a and b being equal to 52. 
In other words, the variable is incremented (or decremented) before it is used to evaluate 
the larger overall expression. 
When you use a postfix notation, you perform the operation without affecting the 
original value of 'a'. Thus, in #4 above, a=52 stays at 52, and 'b' is decremented to 51.
In other words, the variable in 'a' stays the way it is, and 'b' is incremented (or decremented) 
right away. It is only in the following statement (if any) that 'a' is incremented (or decremented). 
If there are no next statement, the variable is lost. 
The increment operator (++): 
is an extremely important unary operator that is used in both Java and C++,
but does not exist in Pascal. 
There is essentially no difference in the behavior of the Java increment operator and the C++ 
increment operator. 
  

I am sorry, Sever, but it looks like the Excel spreadsheet is all screwed up.
Thank you for your help.
Charles.