在 C 中评估赋值运算符的左操作数有啥意义？

Posted 2023-02-25

【中文标题】在 C 中评估赋值运算符的左操作数有啥意义？

【英文标题】：What's the point of evaluating left operand of assignment operator in C?在 C 中评估赋值运算符的左操作数有什么意义？

【发布时间】：2016-12-27 08:25:19

【问题描述】：

根据 ISO C11 - 6.5.16.3，它说

赋值运算符将值存储在由指定的对象中 左操作数。赋值表达式具有左边的值 赋值后的操作数，但不是左值。一个类型 赋值表达式是左操作数之后的类型 左值转换。更新存储值的副作用 左操作数在左的值计算之后排序，并且 右操作数。操作数的计算是无序的。

所以我猜这意味着，例如，

int x = 10;
x = 5 + 10;

左操作数x被评估为10，右操作数被评估为15。 右操作数值存储在左操作数x指定的对象中。

但是，如果赋值的目的是存储右操作数的评估值（就像在步骤 2 中一样），为什么需要评估左操作数？评估左操作数有什么意义？

【问题讨论】：

它在哪里说左操作数被评估？

"左边的值计算后..."

【参考方案1】：

当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 的指针类型表达式？

哇我从来没有听说过这样的概念，评估一个对象。您知道有关该主题的任何好的参考资料吗？

任何关于 C 的书都应该在讨论数组时解释这一点。如果您可以访问 C99 标准，则可以在第 6.5.2.1/2 节中找到：后缀表达式后跟方括号中的表达式 [] 是数组对象元素的下标指定。

作为另一个例子，你可以拥有*f() = 10;，这是一个 LHS 上的函数调用，它返回一个指针，然后解除引用产生一个要分配的对象。

【参考方案2】：

在您的示例中，“左操作数”可能比您简单的 x 复杂得多（诚然，评估并不是一个真正的挑战）：

*(((unsigned long*)target)++) = longValue;

肯定需要对 LHS 进行一些评估。您引用的句子是指在作业的左侧需要做什么才能找到正确的 lvalue 来接收作业。

【参考方案3】：

只是为了从“犹大”的角度说服自己（如果尚未完成），这证明我的帖子只回答了您简单案例中的简单问题。

小证据表明，在您的简单示例中 gcc 只做它需要的，而不是更多：

代码：

int main()

int x = 10;
x = 5 + 10;

return x;

使用调试构建

K:\jff\data\python\***\c>gcc -g -std=c11 -c assign.c

带有混合 C/asm 代码的 objdump

K:\jff\data\python\***\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)，因此评估起来非常简单，我们看不到评估。

你可能是对的。所以为了结束辩论，我用直接混合 C/asm 输出改进了这篇文章。编译器是对的:)

您可以通过使作业的 LHS 更复杂一些来真正加强您的答案，以便我们实际上可以看到更多的评估。

回答加强了。谢谢。我对赞成票感到荣幸，即使它展示了它是如何工作的，而不是其他答案给出的真正解释。 @OP：不要接受那个:)

查看未优化的反汇编确实是一个毫无意义的练习。代码更难阅读，而且根本不是真实世界。

【参考方案4】：

= 左侧有非平凡的表达式，需要一直计算。以下是一些示例。

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!

【参考方案5】：

不然怎么办

int x, y, z;
x = y = z = 5;

工作？ （赋值“z=5”必须将z的（r-）值赋予赋值“y= ...”，然后必须将y的值赋予赋值“x= ...”。 )

幕后行为是：

将值 5 加载到寄存器中（在下面的第 7 步之前不要将此寄存器重复用于其他任何操作） 将z的地址加载到寄存器中（这是“z”用作左值时的含义。） 地址为z的店铺5。 5 现在是“z”的右值。请记住，CPU 使用值和地址，而不是“z”。变量标签“z”是对包含值的内存地址的人类友好引用。根据它的使用方式，我们要么想要它的值（当我们获取 z 的值时），要么想要它的地址（当我们替换 z 的值时）。 在寄存器中加载y的地址。 将z (5) 的值存储在y 的地址。 （应该/可以优化和重用第一步中的“5”。） 将x的地址加载到寄存器中。 将y (5) 的值存储在x 的地址。

【讨论】：

赋值链之所以有效，是因为赋值是 C 中的表达式（不是语句），例如，z = 5 是一个计算结果为 5 的表达式。（它还具有将值存储在 z 中的副作用.) 但这确实与OP的问题无关。

@PaulJ.Lucas ：您似乎不想回答 OP 的问题，“评估左操作数有什么意义？”，他从标准语言“赋值表达式有赋值后左操作数的值......”正如你正确指出的那样，答案就是我写的。

我的评论不适用于 R Sahu 已经回答其问题的 OP。我的评论是对您的“答案”的回应，正如我所指出的，这与 OP 的问题或真实答案无关。

@EricTowers 您的赋值链示例涉及重复评估赋值的右侧。 OP 的问题是关于评估 left 手边。

@jamesdlin：不正确。您的声明会在最右边的子表达式中重复副作用。这与 OP 引用的文本相矛盾：“......在赋值后具有左操作数的值”。试试看：x=y=z++;。 z 增加了多少次？对于评估中的x=((temp)) 步骤，我们计算的右值不是z++，而是新的y（或者我们从嵌套赋值中记住它），但是y 的外部评估是不完整的，直到它强制为可分配给x 的类型。这都是关于评估左侧。