The self-increment operator and the intermediate cache variable mechanism in Java

Transferred from: http://blog.csdn.net/maggiedorami/article/details/7986098

Let's look at a program like this:

2. Public static void Main (string[] args) {
4. int i, SUM1, sum2;
8. i=0;
10. Sum1 = (i++) + (i++);
12. System.out.println ("sum1=" +sum1);
16. i = 0;
18. sum2 = (++i) + (++i);
20. System.out.println ("sum2=" +sum2);
22. }

The result of this operation is:

[Java]View Plaincopy

1. sum1=1
2. sum2=3

And I write the same logic code in C, and I get different results:

[CPP]View Plaincopy

1. void Main ()
2. {
3. int i,sum1,sum2;
5. i=0;
6. Sum1= (i++) + (i++);
7. printf ("sum1=%d\n", sum1);
9. i=0;
10. Sum2= (++i) + (++i);
11. printf ("sum2=%d\n", sum2);
13. GetChar ();
14. }

The result of this operation is:

[CPP]View Plaincopy

1. Sum1=0
2. Sum2=4

This differs because in C, each variable can have only one unique value at each point in its life cycle. As a result, the contents of the corresponding memory area of the variable are rewritten at each increment operation.

In Java, sum1= (i++) + (i++) is executed, and 2 temporary integer variable objects are created to store the results of each self-increment operation.

Java uses the mechanism of this intermediate cache variable.

Then look at the programmer interview a very classic example:

[Java]View Plaincopy

1. Public static void Main (string[] args) {
2. Int J = 0;
3. For (int i = 0; i < ; i++)
4. J = j + +;
5. System.out.println (j);
6. }

For Java, the output value of j is 0.

Because the middle cache variable mechanism of Java causes the j=j++ statement to be decomposed into the following actions:

[Java]View Plaincopy

1. temp = j;
2. j = j + 1;
3. j = temp;

Individuals feel that this use of self-growth is not good, should be in complex statements to avoid the use of post-increment (self-subtraction).

In addition, it is worth noting that some languages that use the mechanism of intermediate cache variables, the output is not necessarily 0. For example, when C + + has a post-increment operation on some basic types and pointer types, the compiler will omit intermediate cache variables.