java有个基本的bug!

这可能是编译的问题
main 函数的字节码如下。
Method void main(java.lang.String[])
0 iconst_0
1 istore_1       //i为标号为1的内存变量中
2 iload_1        //将标号为1的内存变量（i）的值压入运行堆栈中，此时i=0
3 iinc 1 1       //将i所在内存变量值加1，此时i 变量为1
6 istore_1       //赋值：将处理栈顶的值放入标号为1的内存变量中，将该内存的原值覆盖
                //故i又为0
7 getstatic #2 <Field java.io.PrintStream out>
10 iload_1
11 invokevirtual #3 <Method void println(int)>
14 return

大家看看这个，是不是就更晕了！
import java.io.*;public class io
{
public static void main(String[] args)
{
    int i = 0;
    i=i++;
    System.out.println(i);
    i=i+1;
    System.out.println(i);}
}
输出是：0
        1

当然是先0后1了，学TURBO C时也应该知道的啊！先赋值后累加！！！！！！！！！！！

c/c++没学好
int i = 0;
i = i++;
楼上的那位用汇编解释的很清楚！
i=i++中会产生临时引用量i,编译时会忽略。

这个叫BUG?
我真是服了你了。
看看编译原理后，就就知道了。
JAVA认证考这种东西，唐不住！

import java.io.*;
public class Test
{
public static void main(String[] args)
{
    int i = 0,j=0;
       j = i++;
    System.out.println(j);

    System.out.println(i);
}
}
输出为：0
        1
import java.io.*;
public class Test
{
public static void main(String[] args)
{
    int i = 0;
       i = i++;
    System.out.println(i);
    i=i++;
    System.out.println(i);

}
}
输出为：0
        0
谁知道为什么在第二个程序中，第一次给i赋值以后i为0但是马上要又增量1，但是在第二个i=i++的句子中i的初值却仍是1呢？？
谢谢哪个大侠可以解释一下！

你要的结果应该这样写，try it :import java.io.*;
class test
{
public static void main(String[] haha)
{
int i=0;
i++;
System.out.println("i=:"+i);
i=i+1;
System.out.println("i=:"+i);
}
}a=b++ 的意思是先把 b 的值传给 a ,然后 b=b+1

如果是：a=b++ 的意思是先把 b 的值传给 a ,然后 b=b+1
那么是不是：i=i++的意思是先把 i的值传给 i,然后 i=i+1 可是这样不对啊？

：）
其实关于i++，所有的书都说得很清楚啊……
i++以后，i=1，但i++这个表达式的值仍然是0啊……
所以i=i++，i仍然是0……

a = b++ 的意思是：
b++ ( 即 b = b + 1 )
对 b++ 这个表达式求值，值为原来的 b 值
a = (b++ 这个表达式的值，也即原来的 b 值）
所以 a 被赋值为原来的 b 值。把 a、 b 用任何东西代替都成立，包括 a、b 都是 i 的情况。

i = i++;
    ^^^B
^^^^^^^A1) 根据优先级，表达式 B 先求值。
   此时，表达式 B 值为 0， i 值为 1。
2) 然后再计算 A，此时表达式简化为 i = (B)
   由1)得表达式 B 值为 0，因此 i = (B) = 0。
结果，表达式 A 为 0 ， i 值为 0.

我认为确实是BUG！
int i=0;
i=(i++);
java i 为0,c/c++中i为1int i=0;
i=(i++)+(i++);
java i 为1,c/c++中i为2int i=0;
i=(i++)+(i++)+（i++);
java i 为3,c/c++中i为3int i=0;
i=(i++)+(i++)+（i++)+(i++);
java i 为6,c/c++中i为4...
在JAVA中代码生成采用逆波兰式，运行每次是将i值加入运行栈后，接下来立即++，和习惯不一样在C/C++中代码生成是赋值语句（不是表达式）处理完后，才将i加若干遍
通过JAVA的字节码，和C/C++的汇编代码可知。

我只在VC/C++中试过以上代码，不知其他的C/C++编译器如何

事实上
int i=0;
i=(i++)+(i++)+...（共n个）
后，
JAVA 中i==n*(n-1)/2
C/C++中i==n;

实际上，应该是标准的问题吧。
按I_am_me的结果，
也应该是C的BUG吧。

我觉得没什么好争的，实际上有谁会去写这个混蛋的代码？
不过是拿来唬人的罢了。
有了I_am_me的结论后，把话题给结了吧。

我认为楼上你好老兄说得对！i=i++的结果
在于编译器如何解释，c++的解释比较清楚，java
的解释让我困惑了半天。不过听了刚才几位的
说法也有道理，如果把i++作为一个表达
式求值然后再赋给i，结果就是0了。

i =i++;是先运算再自加一
如果i=0,i++加一的效果哪里去了
i++在=运算时先把i=0;然后加一,
那么i好象该是1了,i只有一个地址
temp=i++就不同了,这里temp就是0
给位请指教

import java.io.*;
public class Test
{
public static void main(String[] args)
{
    int i = 0;
       i = i++;
    System.out.println("i(1)"+i);
     int b=++i;
    System.out.println("b="+b);
    System.out.println("i(2)="+i);
}
}
输出为：i(1)0
       b=1
       i(2)=1所以我同意Muf(沐枫)　gun4rose(gun4rose)两位老兄的建议！
上边的两位老兄可以联系一下多多指教么？小弟的oicq :5856874

事实上
int i=0;
int man;
man=(i++)+(i++)+...（共n个）
后，
JAVA 中 man==n*(n-1)/2，i++在表达式内计算
C/C++中 man==0; i++，在赋值语句后计算，我们想象的结果是在表达式后计算。
但是在c/C++的其他语句中，如if(i++>=0){...i/*i为1*/...};i++计算不是在语句后，
而是在表达式后计算，不知为何，可能是BUG？

c/C++中
int i=0;
int man[2];
man[printf("%d\n",i)]=(i++)+(i++)+(i++)+(i++)+(i++);
得到0
说明i++在赋值语句后计算，而不是表达式后计算

ANSI C没有规定在这种情况下表达式的计算次序，所以各种C/C++实现的时候不尽相同。
Java 中对这种情况下如何计算是有规定的，无二义性，具体规定我查了以后再贴出来。

我觉得
int i = 0;
i = i++;
应该这样理解：
int i =0 ;
int temp = i;
i ++;
i = temp;
所以最后i还是等于零

java的bug可多了去了。：）
不过这道题我觉得应该是0啊！？

i=i++是先使用再付值,而i=++i是先付值再使用,明白了么？给分呀！嘻嘻..

就是0么！你们都想什么呢？本来是对的，怎么大家非要说是错的呢！这个程序运行后，理论和实际都应该是0的，没错呀！要是想等于1的话，只好该程序了，把i++改乘++i就行了！ ^o^

In Java, unlike many other languages, the apperent order of evaluation of operands in an expression is fixed. Specifically, the result of any statement will be as if all operands are evaluated left to right, even if the order of execuution of the operations is something different, or if some optimization makes other changes to the reality. This is most noticeable in the case of assignments.
Consider this code fragment:
int a[] = {4, 4};
int b = 1;
a[b] = b = 0;An evaluation from left to right requires that the leftmost expression, a[b], be evaluated, which is simply a reference to the element a[1].
Next , b is evaluated, which is simply a reference to the variable called b.
The constant expression 0 is evaluated next, which clearly does not involve any work.Now that the operands have been evaluated, the operations take place. This is done in the order specified by precedence and associativity.
For assignment, associativity is right-to-left, so the value is first assigned to the variable called b and then the value 0 is assigned into the element of a[1].So, the result is:
b = 0
a[1] = 0Sorry to type in english cause I'm using my Linux Laptop at home. I will translate it to chinese tomorrow in Office.

从朋友的书上抄来的一段，试翻译如下：Java 与其它许多语言不同，在表达式中操作数的计算次序是固定的。特别要指出的是，即使是某些优化可能会改变当前情况，还是操作的实际执行次序是不同的，任何语句的结果都会等同于按从左至右的次序计算一样。在下面的赋值语句中可以特别留意到这一点。
考虑以下代码片段：
int[] a = {4, 4};
int b = 1;
a[b] = b = 0;计算次序从左至右要求首先计算最左边的表达式，a[b]，是一个简单指向 a[1] 的引用。
其次，计算b，也就是一个简单引用指向变量 b。
最后计算常量表达式 0 ，不需要作任何工作。现在各个操作数已被计算出来了，开始运算。这个工作要取决于优先级与相关性。
对于赋值（=）来说，相关性是自右至左，因此0首先被赋给变量 b，接着 0（ b=0 的值）被赋值给数组元素 a[1]。结果就是： b =0, a[1] = 0以上是我试翻译的一段，有什么错误请指出，多谢。再回到我们讨论的 i = i++ 上来：
首先确定各个操作数：第一步是 i ，第二步也是 i
再次确定运算次序： ++ 比 = 优先级高，且后缀 ++ 是左相关的，
因此，先计算 i++，此时 i = 1
再次，计算 i++ 表达式的值，为 0
最后，执行 i = (i++)，此时 i = 0

TO luodi(无知者无畏)　
谢谢，结束了知其然不知其所以然的局面，受益不少。

答案应该是0。这是因为java的编译顺序。i++执行在i=之后。不信将下述程序片执行一个。结果将是1。
import java.io.*;public class Test
{
public static void main(String[] args)
{
    int i = 0;
    i++;
    i=i;//此行不要，结果一样。
    System.out.println(i);
}
}

一群笨蛋！
i=i++
过程是:
i++ //i=1 运行成功True
i=运行成功(True=0)
所以i=0
连基本的左值右值，计算顺序都不知道，还要说Java的bug，唉...

killererer 可不可以再说的清楚一点？？

呵呵,killererer(红雪),i++又不是boolean values,你的结论怎么成立呢?
i=i++;
i++先赋值后累加
首先i=0压栈　
其次累加后i=1压栈
现在需要为i赋值,
赋值：栈顶的值i=1被下面的值i=0覆盖(中间一个处理过程,我也不清)
所以i=0

i=i++;
首先压入栈的是i = 0;(i = i),然后是i=1;(i = i+1),此时i = i++解释完了，从栈中弹出，i 最后的结果就是i=0; 语句的入栈，可以看看大学的《操作系统》。

上面的汇编讲的n好，
可能是这样：
i = i++   本来应该是先赋值，再自增
但编译成了这样：1. 先把i的值放在复制一份（临时的）
               2. i 自增
               3. 再把自增前的值赋出（就是临时的）
也就是上面一个说的运算符优先级造成的吧；）

调试易

java有个基本的bug!

解决方案 »