Java中的自增操作符與中間緩存變量機制

我們來看這樣一段程序：

1. public static void main(String[] args){  
2.      int i, sum1, sum2;  
3.        
4.      i=0;  
5.      sum1 = (i++)+(i++);  
6.      System.out.println("sum1="+sum1);  
7.        
8.      i = 0;  
9.      sum2 = (++i)+(++i);  
10.      System.out.println("sum2="+sum2);     
11. }  

它的運行結果是：

1. sum1=1  
2. sum2=3  

1. void main()    
2. {  
3.     int i,sum1,sum2;  
4.   
5.     i=0;  
6.     sum1=(i++)+(i++);  
7.     printf("sum1=%d\n",sum1);  
8.   
9.     i=0;  
10.     sum2=(++i)+(++i);  
11.     printf("sum2=%d\n",sum2);  
12.   
13.     getchar();  
14. }  

它的運行結果是：

1. sum1=0  
2. sum2=4  

這種不同是因為在c語言中，每個變量在它的生命周期內的每個時間點都只能有一個唯一的值。因此變量在每一次自增運算時，變量所對應內存區域的內容就被重寫了。

而在java中，執行sum1=(i++)+(i++);創建了2個臨時的整型變量對象，對來存儲每次自增運算的結果。

java采用了這種中間緩存變量的機制。

再看程序員面試寶典中一個很經典的例子：

1. public static void main(String[] args){   
2.         int j = 0;   
3.         for(int i = 0; i < 100; i++)   
4.             j = j++;   
5.         System.out.println(j);   
6.     }   

因為java的中間緩存變量機制使j=j++語句看以分解成如下操作：

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

個人覺得這樣使用自增並不好，應該在復雜語句中避免使用後置的自增（自減）。

另外，值得注意的是某些采用了中間緩存變量機制的語言，輸出並不一定是0。比如C++在對一些基本類型以及指針類型進行後置自增操作時，編譯器將省去中間緩存變量的操作。