int index=1;count=10;执行index=(index++) % count;后输出结果为何还是1

Question

如题，在c语言,java也是这样吗？不是index先自加变成2，然后在求余吗？

Answer 1

index++ 是个表达式，会先对它求值 其实就是index的值  然后看运算符等级而定之后的操作% 比 ++ 等级高会先执行 所以是先取余  然后index 自增

Answer 2

然后index 自增
然后我把自增后的结果赋值会index，可是结果还是1，不是2吗

Answer 3

int index = 1;
count = 10;
index = (index++) % count;相当于int index = 1;
count = 10;
index = ((index++) % count);
index % count 传给 index
index++ 的结果被抛弃。

Answer 4

int i = 1;
i = i++; // i = 1。

Answer 5

请深刻理解index++和++index的区别index = (++index) % count;index为2

Answer 6

此结果如果是别的数那就怪了。可以考虑　index=(++index)%10 ,index的值应该会变。

Answer 7

这类问题也是经久不衰...i++，先返回i值再自增...index=(index++) % count 只相当于 index=index % count...跟运算符优先级还真没关系，因为++比%优先级高，()号具有最高优先级...这个表达式有没有括号都一样...

Answer 8

我重新说一下，#1的回复有些偏差。index=(index++)%count实际的执行过程是 先对()内进行求值 因为index++ 是表达式 它的结果是返回index的值 所以这里有无()一样然后因为运算符优先级的缘故 ++ 比 % 优先级高 会先进行++操作，所以index=2但index=2改变不了 index++ 这个表达式=1的结果 所以接下来还是进行 1对10 取余的操作并将结果赋值给 index  也就是1最后 index=1  但在运算的过程中 index 是有=2的时候，只是后来被冲掉(覆盖)了某些 java 大全中 经常出类似的问题 貌似sun 自己的书中也有此内容，记忆衰退有些记不清了

Answer 9

但index=2改变不了 index++ 这个表达式=1的结果  
这句话重点，谢谢各位啦

Answer 10

前几天有人问类似的问题，过客给出了一段反汇编程序。
被抛弃这个说法是指编译器把这个结果“丢掉了”。的确编译器没有产生把自增以后的结果move给变量的操作。

Answer 11

阿非你想复杂了...这里的确跟运算符优先级没关系，虽然后缀自增运算符x++是最高优先级，但这里仅仅是index++返回值就是index的问题，谁先谁后都不会影响结果...

Answer 12

所谓“被抛弃”也是自增运算符规则的问题，后缀自增是先“返回”值...所以这个表达式用到的是这个返回值而不是index本身的值...然后这个表达式结果又被赋值给index，这会导致之前的自增操作结果被覆盖...

Answer 13

兄弟，请一定看我的回复。
int x=1;int=y；y=x  ;y结果是1。int x=1；y=0； x  ； y=x；输出x结果是2。这个看明白后你就明白了，相信对你很简单，不要把简单的问题混淆，补一下基础。

Answer 14

被抛弃这个说法是指编译器把这个结果“丢掉了”。的确编译器没有产生把自增以后的结果move给变量的操作。
----------------------------------------------------------------------------------但从结果上来看 如果是 编译器把这个结果“丢掉了” 没有合理的解释的话，那岂不是是编译器的BUG可以肯定的是 肯定不是编译器的BUG， 那是不是倒推回来就是结论（编译器把这个结果“丢掉了”）不合理。
“的确编译器没有产生把自增以后的结果move给变量的操作。”实际执行的是堆栈的出栈操作，Stloc 。 至于 Stloc 将当前值存储到什么位置，要看相应局部变量的索引(下标)

Answer 15

是，我可能没说清楚。优先级不会影响到 index++ 这个表达式的取值但是了解优先级会清楚后续的操作， 所以说优先级有关系

Answer 16

是的，我在#13 也说明了 index=1 的原因。 也阐述了 “被抛弃” 不太准确的根据

Answer 17

int index = 1;
            int count = 10;
            int j = (index++) % count;IL如下：
.locals init ([0] int32 index,
           [1] int32 count,
           [2] int32 j)
  IL_0000:  nop
  IL_0001:  ldc.i4.1  //整数1入栈
  IL_0002:  stloc.0 //弹栈顶给index
  IL_0003:  ldc.i4.s   10 //整数10入栈
  IL_0005:  stloc.1 //弹栈顶给count
  IL_0006:  ldloc.0 //index的值入栈
  IL_0007:  dup //复制栈顶，现在栈顶部两个都放着值1
  IL_0008:  ldc.i4.1 //整数1入栈
  IL_0009:  add //栈顶部两个元素相加
  IL_000a:  stloc.0 //相加结果弹给index，index变量为2，栈顶还有一个1
  IL_000b:  ldloc.1 //count的值入栈
  IL_000c:  rem
  IL_000d:  stloc.2
  IL_000e:  ret

Answer 18

C/C++中，++、--运算符的优先级要高于加减乘除、%操作；
x=((y++) + (x++));这样的语句，是先把x+y的值先赋给x，然后x，y再各自做增一运算；、#include<stdio.h>void main()
{
int index = 1;
int count = 10;
printf("%d\n",index = (index++) % count);
printf("%d\n", index);
}输出的结果：
1
2
所以，楼上的应该都明白了，index = (index++) % count; 先把index % count赋值给index，结束后index自加1;

Answer 19

如果是index = (++index) % count 那一定没有争议，只是这个单目运算符在后边，虽然优先级很高，但生效的时间比中国邮政还要慢，要等到运算结束才自加。

Answer 20

i = i++;这个语句本身的值为1，但再输出变量i时，就自加1，变成2了；因为是使用后自加，所以是2；#include<stdio.h>void main()
{
int i = 1;
printf("%d\n",i = i++);
printf("%d\n", i);
}
输出结果：
1
2

Answer 21

那个是在后面 index++；
如果是(++index)才是先加再用

Answer 22

不知你是否作过测试？
i=1;
i=(i++)%10;
无论哪种语言中都不会得到i=2的结果吧。

Answer 23

i=1;
i=(i++)%10; i=1
j=i;        j=2

Answer 24

i=1;
i=(++i)%10; i=2
j=i; j=2

Answer 25

如同 
i=1;
i=i++;
j=i;i=1;
i=++i;
j=i;

Answer 26

相当于int temp = index++;
index = temp % 10;ps.lz还是尽量不要用这种容易带来困扰的写法

Answer 27

说明你的C，java学的不扎实
C,java,C#里面的++运算符都是一样的,例如 
index++:index先进行运算再进行自增
++index:index先进行自增再进行运算
唯一相同的地方就是，最后index的值都是增加了1
   int index = 1;
            int count = 10;
            int temp = 1;
            index = (index++) % count;
            temp = (++temp) % count;
            Console.WriteLine(index);
            Console.WriteLine(temp);
            /*result:
             * 1
             * 2
             * */
            Console.ReadKey();     

Answer 28

java不知道，C里面属于未定义行为～

Answer 29

CentOS 5.3 64位系统，gcc 版本 4.1.2 20080704 (Red Hat 4.1.2-50)
[root@c0108 zlt]# cat test.c
#include<stdio.h>int  main()
{
    int i = 1;
    printf("%d\n",i = (i++)%10);
    printf("%d\n", i);
    return 1;
}
[root@c0108 zlt]# gcc test.c -o test
[root@c0108 zlt]# ./test
1
2
[root@c0108 zlt]# 
windows 7 32位系统，visual studio 2008输出同样的结果。你也可以试一下。"i = (i++)%10"这个表达式本身，也即此时i的值，并没有自增1，运算结束后，自增1，所以再次输出时i的值时，就成了2;
 40楼不可以理解成是速度太慢了

Answer 30

++运算符在C/C++与C#/JAVA中的差异 
http://blog.csdn.net/Sandy945/archive/2011/06/06/6527888.aspx
http://www.cnblogs.com/Sandy945/archive/2011/06/06/2073613.html