Ubuntu中文论坛

void strcpy(char *s,char *t)
{
    while (*s++ = *t++)
        ;
}

(1)*t 的赋值给 *s
(2)判断 *s 是否为真。如果为假，则跳出循环；否则继续执行第(3)步。因为字符串是以\0结尾的，遇到\0的时候，也就是*s为假，就跳出了字符串拷贝。
(3)s 和 t 加 1，指向下一个地址，准备拷贝下一个字符。

(1) 取t和s的值t'和s'到内存的某个位置；
(2) 取出*t' 和*s'；
(3) *t' 的赋值给 *s'；
(4) 判断 *s' 是否为真。如果为假，则跳出循环，否则继续执行(5)步；
(5) s 和 t 加 1。

1. 根据运算符优先级，后自增运算符的优先级比赋值高，所以顺序是(1)(2)(5)(3)(4)；
2. 根据运算符优先级，后自增运算符的优先级比提领(*)高，所以取出t' 和s' 后应该先对t和s进行自增，然后在取*t' 和*s'，
所以正确的顺序应该是(1)(5)(2)(3)(4)。

linjiework 写了：这段代码也算漂亮？

要是谁在工作中这么写，那他离被开除不远了。

HuntXu 写了：后缀运算的表达式值是不变的...

灰色小狼 写了：事实证明我的想法是错误的，这是一个简单的测试程序：

代码： 全选

#include <stdio.h>

void copy(char *, char *);

int main()
{
	char t[] = "Hello world!";
	char s[] = "";
	copy(s, t);
	printf("%s\n", s);
}

void copy(char *s,char *t)
{
	while (*s++ = *t++)
		;
}

[/color]

这是它的汇编代码：

代码： 全选

	.file	"strcopy.c"
	.section	.rodata
.LC0:
	.string	""
	.text
.globl main
	.type	main, @function
main:
	pushl	%ebp
	movl	%esp, %ebp
	andl	$-16, %esp
	subl	$48, %esp
	movl	%gs:20, %eax
	movl	%eax, 44(%esp)
	xorl	%eax, %eax
	movl	$1819043144, 31(%esp)
	movl	$1870078063, 35(%esp)
	movl	$560229490, 39(%esp)
	movb	$0, 43(%esp)
	movzbl	.LC0, %eax
	movb	%al, 30(%esp)
	leal	31(%esp), %eax
	movl	%eax, 4(%esp)
	leal	30(%esp), %eax
	movl	%eax, (%esp)
	call	copy
	leal	30(%esp), %eax
	movl	%eax, (%esp)
	call	puts
	movl	44(%esp), %edx
	xorl	%gs:20, %edx
	je	.L3
	call	__stack_chk_fail
.L3:
	leave
	ret
	.size	main, .-main
.globl copy
	.type	copy, @function
copy:
	pushl	%ebp
	movl	%esp, %ebp
.L5:
	movl	12(%ebp), %eax
	movzbl	(%eax), %edx
	movl	8(%ebp), %eax
	movb	%dl, (%eax)
	movl	8(%ebp), %eax
	movzbl	(%eax), %eax
	testb	%al, %al
	setne	%al
	addl	$1, 8(%ebp)
	addl	$1, 12(%ebp)
	testb	%al, %al
	jne	.L5
	popl	%ebp
	ret
	.size	copy, .-copy
	.ident	"GCC: (Ubuntu/Linaro 4.4.4-14ubuntu5) 4.4.5"
	.section	.note.GNU-stack,"",@progbits

[/color]

那么现在的问题就是：后自增比赋值的优先级要高，而表面上看上去自增却发生在赋值之后，我认为我的说法可以解释这个问题（赋值掉取的是原变量在内存中的一个副本，而变量本身已经增加了），但从汇编的代码不支持这个说法，那么怎么解释这里的优先级问题呢？哪位高手能不能举个例子展示一下后自增比赋值的优先级要高呢？

BigSnake.NET 写了： 4. 所谓的优先级不是指运算顺序，是指结合性 例如 a = b++ 是理解成 a = (b++) 而不是 (a = b) ++, 那个 b 的自增不保证在赋值之后执行， 但是赋值给 a 的一定是 b 自增之前的值