[已解决]优先级问题

竹逸

while((*to++=*from++)!='\0');
这条语句，把from指向的值覆盖to指向的值后，

接下来是先自增1再判断是否不等于0，还是先判断是否不等于0再自增1？

最佳答案

月排行榜 / 总排行榜

人造人

2022-10-2 23:53:54

先判断0，然后再加

跳转到最佳答案楼层

人造人

先判断0，然后再加

人造人

1. int main(void) {
   
2.     1119:       55                      pushq  %rbp
   
3.     111a:       48 89 e5                movq   %rsp,%rbp
   
4.     int *from = NULL;
   
5.     111d:       48 c7 45 f0 00 00 00    movq   $0x0,-0x10(%rbp)
   
6.     1124:       00
   
7.     int *to = NULL;
   
8.     1125:       48 c7 45 f8 00 00 00    movq   $0x0,-0x8(%rbp)
   
9.     112c:       00
   
10.     while((*to++ = *from++) != '\0');
    
11.     112d:       90                      nop
    
12.     112e:       48 8b 55 f0             movq   -0x10(%rbp),%rdx
    
13.     1132:       48 8d 42 04             leaq   0x4(%rdx),%rax
    
14.     1136:       48 89 45 f0             movq   %rax,-0x10(%rbp)
    
15.     113a:       48 8b 45 f8             movq   -0x8(%rbp),%rax
    
16.     113e:       48 8d 48 04             leaq   0x4(%rax),%rcx
    
17.     1142:       48 89 4d f8             movq   %rcx,-0x8(%rbp)
    
18.     1146:       8b 12                   movl   (%rdx),%edx
    
19.     1148:       89 10                   movl   %edx,(%rax)
    
20.     114a:       8b 00                   movl   (%rax),%eax
    
21.     114c:       85 c0                   testl  %eax,%eax
    
22.     114e:       75 de                   jne    112e <main+0x15>
    
23.     return 0;
    
24.     1150:       b8 00 00 00 00          movl   $0x0,%eax
    
25. }
    
26.     1155:       5d                      popq   %rbp
    
27.     1156:       c3                      retq
    

复制代码

竹逸

人造人 发表于 2022-10-2 23:53
先判断0，然后再加

好的，我发现无论条件是否为真，都会自增1，不受是否进入循环体的影响

竹逸

人造人 发表于 2022-10-2 23:56

这个汇编看不太懂，我0基础都没看完

人造人

竹逸 发表于 2022-10-3 01:23
这个汇编看不太懂，我0基础都没看完

1. ! 1
   
2. ! 1 # 1 "main.c"
   
3. ! 1 # 6
   
4. ! 6 int main() {
   
5. export  _main
   
6. _main:
   
7. ! 7     int *from = ((void *)0) ;
   
8. push    bp
   
9. mov     bp,sp
   
10. push    di
    
11. push    si
    
12. dec     sp
    
13. dec     sp
    
14. ! Debug: eq * void = const 0 to * int from = [S+8-8] (used reg = )
    
15. xor     ax,ax
    
16. mov     -6[bp],ax
    
17. !BCC_EOS
    
18. ! 8     int *to = ((void *)0) ;
    
19. dec     sp
    
20. dec     sp
    
21. ! Debug: eq * void = const 0 to * int to = [S+$A-$A] (used reg = )
    
22. xor     ax,ax
    
23. mov     -8[bp],ax
    
24. !BCC_EOS
    
25. ! 9     while((*to++ = *from++) != '\0');
    
26. jmp .2
    
27. .3:
    
28. !BCC_EOS
    
29. ! 10     return 0;
    
30. .2:
    
31. ! Debug: postinc * int from = [S+$A-8] (used reg = )
    
32. mov     bx,-6[bp]
    
33. inc     bx
    
34. inc     bx
    
35. mov     -6[bp],bx
    
36. ! Debug: postinc * int to = [S+$A-$A] (used reg = bx)
    
37. mov     si,-8[bp]
    
38. inc     si
    
39. inc     si
    
40. mov     -8[bp],si
    
41. ! Debug: eq int = [bx-2] to int = [si-2] (used reg = )
    
42. mov     bx,-2[bx]
    
43. mov     -2[si],bx
    
44. ! Debug: ne int = const 0 to int = bx+0 (used reg = )
    
45. test    bx,bx
    
46. jne     .3
    
47. .4:
    
48. .1:
    
49. xor     ax,ax
    
50. add     sp,*4
    
51. pop     si
    
52. pop     di
    
53. pop     bp
    
54. ret
    
55. !BCC_EOS
    
56. ! 11 }
    
57. ! 12
    
58. ! Register BX SI used in function main
    
59. .data
    
60. .bss
    
61. 
    
62. ! 0 errors detected
    

复制代码

人造人

先判断0，然后再加

如果你能看懂汇编语言，你就会发现这个说法不准确
不能说不对，只能是不准确
或者说成是，在C语言层正确，在汇编语言层错误，至少是上面那两个汇编语言中错误

因为标准规定C语言中的副作用最迟在下一个顺序点之前必须全部完成，并没有说最早在什么时候
所以在C语言中说  “先判断0，然后再加” 就不能说错
因为C语言中，i++ 的语义就是先使用 i，然后再对 i 加一
https://blog.csdn.net/simon_xia_uestc/article/details/20834535

但是从上面这两个汇编语言代码的角度看，“先判断0，然后再加” 就是错误的


我不知道你现在是什么情况
要么就先学C语言，把不懂的问题留给第二次学C语言的时候解决
要么就先学汇编语言，然后再站在汇编语言的角度学C语言，解决那些第一次学C语言的时候没有解决的问题

竹逸

人造人 发表于 2022-10-3 11:08
先判断0，然后再加

如果你能看懂汇编语言，你就会发现这个说法不准确

先学c吧，汇编以后要用到破解的知识再回头学