竹逸 发表于 2022-10-2 23:44:02

优先级问题

本帖最后由 竹逸 于 2022-10-2 23:54 编辑

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

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

人造人 发表于 2022-10-2 23:53:54

先判断0，然后再加

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

int main(void) {
    1119:       55                      pushq%rbp
    111a:       48 89 e5                movq   %rsp,%rbp
    int *from = NULL;
    111d:       48 c7 45 f0 00 00 00    movq   $0x0,-0x10(%rbp)
    1124:       00
    int *to = NULL;
    1125:       48 c7 45 f8 00 00 00    movq   $0x0,-0x8(%rbp)
    112c:       00
    while((*to++ = *from++) != '\0');
    112d:       90                      nop
    112e:       48 8b 55 f0             movq   -0x10(%rbp),%rdx
    1132:       48 8d 42 04             leaq   0x4(%rdx),%rax
    1136:       48 89 45 f0             movq   %rax,-0x10(%rbp)
    113a:       48 8b 45 f8             movq   -0x8(%rbp),%rax
    113e:       48 8d 48 04             leaq   0x4(%rax),%rcx
    1142:       48 89 4d f8             movq   %rcx,-0x8(%rbp)
    1146:       8b 12                   movl   (%rdx),%edx
    1148:       89 10                   movl   %edx,(%rax)
    114a:       8b 00                   movl   (%rax),%eax
    114c:       85 c0                   testl%eax,%eax
    114e:       75 de                   jne    112e <main+0x15>
    return 0;
    1150:       b8 00 00 00 00          movl   $0x0,%eax
}
    1155:       5d                      popq   %rbp
    1156:       c3                      retq

竹逸 发表于 2022-10-2 23:56:33

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

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

竹逸 发表于 2022-10-3 01:23:23

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


这个汇编看不太懂，我0基础都没看完{:10_266:}

人造人 发表于 2022-10-3 10:48:20

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

! 1
! 1 # 1 "main.c"
! 1 # 6
! 6 int main() {
export_main
_main:
! 7   int *from = ((void *)0) ;
push    bp
mov   bp,sp
push    di
push    si
dec   sp
dec   sp
! Debug: eq * void = const 0 to * int from = (used reg = )
xor   ax,ax
mov   -6,ax
!BCC_EOS
! 8   int *to = ((void *)0) ;
dec   sp
dec   sp
! Debug: eq * void = const 0 to * int to = (used reg = )
xor   ax,ax
mov   -8,ax
!BCC_EOS
! 9   while((*to++ = *from++) != '\0');
jmp .2
.3:
!BCC_EOS
! 10   return 0;
.2:
! Debug: postinc * int from = (used reg = )
mov   bx,-6
inc   bx
inc   bx
mov   -6,bx
! Debug: postinc * int to = (used reg = bx)
mov   si,-8
inc   si
inc   si
mov   -8,si
! Debug: eq int = to int = (used reg = )
mov   bx,-2
mov   -2,bx
! Debug: ne int = const 0 to int = bx+0 (used reg = )
test    bx,bx
jne   .3
.4:
.1:
xor   ax,ax
add   sp,*4
pop   si
pop   di
pop   bp
ret
!BCC_EOS
! 11 }
! 12
! Register BX SI used in function main
.data
.bss

! 0 errors detected

人造人 发表于 2022-10-3 11:08:07

本帖最后由 人造人 于 2022-10-3 11:09 编辑

先判断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-5 02:02:39

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

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


先学c吧，汇编以后要用到破解的知识再回头学{:10_247:}
页: [1]
查看完整版本: 优先级问题