Operators with ++ and =

[Nuwan Hettiarachchi]

Hi all...
I'm confused with the following syntaxes. First of all I have noticed several posts regarding precedence in this forum and for some Bates has answered saying such topics will be rare in SCJP5.0 onwards. However, since this was a scenario that we have discussed in the class... Can some one give some insight on what is happening in this code. I have put my experimental results on the code saying what were my outputs.

   class operators{
static int f1(int i) {
System.out.print(i + ",");
return i; // Change A
}
public static void main (String[] args) {
int i = 0;
 
i=0;
i = i++ ; // 0 - Assign and increment
System.out.println("   ++i            -> " + i);
 
i=0;
i = ++i ; // 1 - Increment and Assign
System.out.println("     i++          -> " + i);
                                                         // ======= Change A =======
i=0;                                             // With.. return 0; --  return i;   
i = i++ + (f1(i)); // 1                          //   
System.out.println("     i++ + f1(i)  -> " + i); //   1, 0                   1, 1             
                                                         //                  
i=0;                                             //                  
i = ++i + (f1(i)); // 2                          //                  
System.out.println("     ++i + f1(i)  -> " + i); //   1, 1                   1, 2 
                                                         //                  
i=0;                                             //                  
i = i++ + (f1(i++));  // 3                       //                  
System.out.println("     i++ + f1(i++)  -> "+ i);//   1, 0                   1, 1 
 
}
} 

I have tested for two scenarios,
1. with f1() returning 0;
2. with f1() returning i;

Based on the values I get; should I consider for Scenario 1,
i=i++ + (f1(i)) happened like i++ done first and then the incremented value is passed to f1(i) (That should be why I get 1 printed for this), and then again when assigning to i (i=part on Right hand side) the value that is incremented is not considered?

I hope I can figure out answers for other cases if I get my confusion cleared for this...


Thanks in advance.

Nuwan

[fred rosenberger]

I'm not sure I understand exactly what you are asking... If i simplify your code to the basics of what i THINK you are asking, we get this:

class operators{
  static int f1(int i) 
  {
    System.out.println("in f1:" + i + ",");
      return i; // Change A
  }
  public static void main (String[] args) 
  {
    int i = 0;
    i = i++ + (f1(i)); 
    System.out.println("i++ + f1(i)  -> " + i);
   }
}

and you want to know why the result it 1?

i starts as 0. we now get to this line:

i = i++ + (f1(i));

so, first we evaluate i - it's 0, and increment it (that's the i++). we then evaluate i - it's 1, and pass that to f1. f1 returns the value of i, which is 1. we now do the addition. 0 + 1 is 1. we assign that to i.

Let us know if that helps, or if i didn't answer the question.

[Nuwan Hettiarachchi]

Thanks for the reply...

I think I have found the answer from you.

first we evaluate i - it's 0, and increment it (that's the i++)

1. Evaluate
2. Increment (adjust the value)
3. Use the adjusted value for the method call
4. Still i = i++ + (f1(i)); is evaluated with i's unadjusted value. so i= 0 + 1

My confusion was weather to use the adjusted value or not.

Thank
For the reply.

[fred rosenberger]

My confusion was weather to use the adjusted value or not.

it won't matter if you have

i=0;
i++ + f1(i)

or

i=0;
++i + f1(i)

at least as far as what's passed to f1. in both cases, i will have been incremented to 1 for the method call.

the value used in that addition will be different, though. the first example, the jvm thinks 'use the value of i here, then increment it". in the second case, the jvm thinks "ok, increment i and use that in this spot".

In both cases, by the time you get to the method call, i has become 1.

[Ben Souther]

"Nuwan H",
Please check your private messages regarding an important administrative matter.
-Ben