根据 ISO C11 - 6.5.16.3，它说
- 赋值运算符将值存储在由指定的对象中 左操作数。赋值表达式具有左边的值 赋值后的操作数，但不是左值。一个类型 赋值表达式是左操作数之后的类型 左值转换。更新存储值的副作用 左操作数在左的值计算之后排序，并且 右操作数。操作数的计算是无序的。
所以我猜这意味着，例如，
int x = 10;
x = 5 + 10;
x被评估为10，右操作数被评估为15。x指定的对象中。但是，如果赋值的目的是存储右操作数的评估值（就像在步骤 2 中一样），为什么需要评估左操作数？评估左操作数有什么意义？
【问题讨论】：
标签： c assignment-operator evaluation
当x 被评估为lvalue 时，它不会评估为10。它会评估为lvalue，其中可以存储RHS 的值。如果 LHS 未计算为 lvalue，则该语句将出错。
来自 C99 标准 (6.3.2.1/1)：
lvalue 是一个表达式（对象类型不是 void），它可能指定一个对象；如果 lvalue 在评估时未指定对象，则行为未定义。
当您有一个简单的变量时，将 LHS 评估为 左值 是微不足道的，例如
x = 10;
但是，它可能更复杂。
double array[10];
int getIndex(); // Some function that can return an index based
// on other data and logic.
array[getIndex()+1] = 10.0;
// This looks like a function call that returns a value.
// But, it still evaluates to a "storage area".
int *getIndex2() { return(&array[0]); }
*getIndex2()=123.45; // array[0]=123.45
如果 getIndex() 返回 5，则 LHS 求值为指定数组的第 7 个元素的 左值。
【讨论】：
array[getIndex()+1] 没有被评估为某个指针值，而是被评估为某个指向 int 的指针类型表达式？
[] 是数组对象元素的下标指定。
*f() = 10;，这是一个 LHS 上的函数调用，它返回一个指针，然后解除引用产生一个要分配的对象。
在您的示例中，“左操作数”可能比您简单的 x 复杂得多（诚然，评估并不是一个真正的挑战）：
*(((unsigned long*)target)++) = longValue;
肯定需要对 LHS 进行一些评估。您引用的句子是指在作业的左侧需要做什么才能找到正确的 lvalue 来接收作业。
【讨论】：
只是为了从“犹大”的角度说服自己（如果尚未完成），这证明我的帖子只回答了您简单案例中的简单问题。
小证据表明，在您的简单示例中 gcc 只做它需要的，而不是更多：
代码：
int main()
{
int x = 10;
x = 5 + 10;
return x;
}
使用调试构建
K:\jff\data\python\stackoverflow\c>gcc -g -std=c11 -c assign.c
带有混合 C/asm 代码的 objdump
K:\jff\data\python\stackoverflow\c>objdump -d -S assign.o
assign.o: file format pe-x86-64
Disassembly of section .text:
0000000000000000 <main>:
int main()
{
0: 55 push %rbp
1: 48 89 e5 mov %rsp,%rbp
4: 48 83 ec 30 sub $0x30,%rsp
8: e8 00 00 00 00 callq d <main+0xd>
int x = 10;
d: c7 45 fc 0a 00 00 00 movl $0xa,-0x4(%rbp)
x = 5 + 10;
14: c7 45 fc 0f 00 00 00 movl $0xf,-0x4(%rbp)
return x;
1b: 8b 45 fc mov -0x4(%rbp),%eax
}
1e: 90 nop
1f: 48 83 c4 30 add $0x30,%rsp
23: 5d pop %rbp
24: c3 retq
25: 90 nop
26: 90 nop
27: 90 nop
28: 90 nop
29: 90 nop
2a: 90 nop
2b: 90 nop
2c: 90 nop
2d: 90 nop
2e: 90 nop
2f: 90 nop
正如其他（不错的）答案中所述，不愿意解释，但如果表达式更复杂，则必须计算存储值的地址，因此需要进行某种评估。
编辑：
使用一些稍微复杂的代码：
int main()
{
int x[3];
int i = 2;
x[i] = 5 + 10;
return x[i];
}
反汇编：
Disassembly of section .text:
0000000000000000 <main>:
int main()
{
0: 55 push %rbp
1: 48 89 e5 mov %rsp,%rbp
4: 48 83 ec 30 sub $0x30,%rsp
8: e8 00 00 00 00 callq d <main+0xd>
int x[3];
int i = 2;
d: c7 45 fc 02 00 00 00 movl $0x2,-0x4(%rbp)
x[i] = 5 + 10;
14: 8b 45 fc mov -0x4(%rbp),%eax <== hey, could be more optimized here: movl $0x2,%eax covers line+above line :)
17: 48 98 cltq
19: c7 44 85 f0 0f 00 00 movl $0xf,-0x10(%rbp,%rax,4) <== this line holds the left-operand evaluation, in a way, %rax is used to offset the array address
20: 00
return x[i];
21: 8b 45 fc mov -0x4(%rbp),%eax
24: 48 98 cltq
26: 8b 44 85 f0 mov -0x10(%rbp,%rax,4),%eax
}
2a: 90 nop
2b: 48 83 c4 30 add $0x30,%rsp
2f: 5d pop %rbp
30: c3 retq
【讨论】：
x = 10 与 LHS 的评估并不完全一致 - 您标记的内容指的是作业 int x = 10。 LHS 在这里只是-4(rbp)，因此评估起来非常简单，我们看不到评估。
= 左侧有非平凡的表达式，需要一直计算。以下是一些示例。
int array[5];
int *ptr = malloc(sizeof(int) * 5);
*ptr = 1; // The lhs needs to evaluate an indirection expression
array[0] = 5; // The lhs needs to evaluate an array subscript expression
for (int i = 0; i < 5; ++i) {
*ptr++ = array[i]; // Both indirection and postincrement on the lhs!
}
// Here, we want to select which array element to assign to!
int test = (array[4] == 0);
(test ? array[0] : array[1]) = 5; // Both conditional and subscripting!
【讨论】：
不然怎么办
int x, y, z;
x = y = z = 5;
工作？ （赋值“z=5”必须将z的（r-）值赋予赋值“y= ...”，然后必须将y的值赋予赋值“x= ...”。 )
幕后行为是：
z的地址加载到寄存器中（这是“z”用作左值时的含义。）z的店铺5。 5 现在是“z”的右值。请记住，CPU 使用值和地址，而不是“z”。变量标签“z”是对包含值的内存地址的人类友好引用。根据它的使用方式，我们要么想要它的值（当我们获取 z 的值时），要么想要它的地址（当我们替换 z 的值时）。y的地址。z (5) 的值存储在y 的地址。 （应该/可以优化和重用第一步中的“5”。）x的地址加载到寄存器中。y (5) 的值存储在x 的地址。【讨论】：
z = 5 是一个计算结果为 5 的表达式。（它还具有将值存储在 z 中的副作用.) 但这确实与OP的问题无关。
x=y=z++;。 z 增加了多少次？对于评估中的x=((temp)) 步骤，我们计算的右值不是z++，而是新的y（或者我们从嵌套赋值中记住它），但是y 的外部评估是不完整的，直到它强制为可分配给x 的类型。这都是关于评估左侧。