operaciones - operadores de asignacion en c++

¿Cuál es el punto de evaluar el operando izquierdo del operador de asignación en C?

Question

Según la norma ISO C11 - 6.5.16.3, dice que

3. Un operador de asignación almacena un valor en el objeto designado por el operando izquierdo. Una expresión de asignación tiene el valor del operando izquierdo después de la asignación, pero no es un valor l. El tipo de una expresión de asignación es el tipo que tendría el operando izquierdo después de la conversión de lvalue. El efecto secundario de actualizar el valor almacenado del operando izquierdo se secuencia después de los cálculos de valor de los operandos izquierdo y derecho. Las evaluaciones de los operandos no son posteriores.

Así que supongo que esto significa que, por ejemplo,

int x = 10;
x = 5 + 10;

1. El operando izquierdo x se evalúa a 10 y el operando derecho se evalúa a 15.
2. El valor del operando derecho se almacena en el objeto designado por el operando izquierdo x .

Pero si el propósito de la asignación es almacenar el valor evalado del operando derecho (como en el paso 2), ¿por qué es necesaria la evaluación del operando izquierdo? ¿Cuál es el punto de evaluar el operando izquierdo?

Answer 1

Como si no

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

¿trabajo? (La asignación " z=5 " debe dar el valor (r-) de z a la asignación " y= ... ", que luego debe dar el valor de y a la asignación " x= ... ". )

El comportamiento bajo el capó es:

1. Cargue el valor 5 en un registro (y no reutilice este registro para nada más hasta el paso 7, a continuación)
2. Cargar la dirección de z en un registro (Esto es lo que significa " z " cuando se usa como valor l.)
3. Almacenar 5 en la dirección de z . 5 es ahora el valor de " z ". Recuerde que las CPU funcionan con valores y direcciones, no con " z ". La etiqueta variable " z " es un referente amigable para el ser humano a una dirección de memoria que contiene un valor. Dependiendo de cómo se use, desearemos su valor (cuando obtengamos el valor de z ) o su dirección (cuando reemplazemos el valor de z ).
4. Cargar la dirección de y en un registro.
5. Almacene el valor de z (5) en la dirección de y . (Uno debería / podría optimizar y reutilizar el "5" desde el primer paso.)
6. Cargue la dirección de x en un registro.
7. Almacene el valor de y (5) en la dirección de x .

Answer 2

Cuando x se evalúa como un lvalue , no se evalúa como 10. Se evalúa como un lvalue donde se puede almacenar el valor de RHS. Si el LHS no se evalúa como un valor de lvalue , la declaración sería un error.

De la norma C99 (6.3.2.1/1):

Un lvalue es una expresión (con un tipo de objeto distinto de vacío) que potencialmente designa un objeto; Si un valor de l no designa un objeto cuando se evalúa, el comportamiento no está definido.

La evaluación de la LHS como un valor lime es trivial cuando tiene una variable simple, como

 x = 10;

Sin embargo, puede ser más complejo.

 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

Si getIndex() devuelve 5 , entonces el LHS se evalúa como un valor de l que designa el 7º elemento de la matriz.

Answer 3

Solo para convencerme (si no lo he hecho) desde el punto de vista de "Judas", lo que justifica que mi publicación solo responda a la pregunta simple en su caso simple.

pequeña prueba que muestra que en su ejemplo simple gcc hace exactamente lo que necesita, no más:

código:

int main()
{
int x = 10;
x = 5 + 10;
return x;
}

construir con depuración

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

objdump con código C / asm entremezclado

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

Como se indica en las otras respuestas (agradables), no está dispuesto a parafrasear, pero si la expresión es más compleja, la dirección para almacenar el valor debe calcularse, por lo que es necesaria una evaluación de algún tipo.

EDITAR:

Con un código un poco más complejo:

int main()
{
int x[3];
int i = 2;
x[i] = 5 + 10;
return x[i];
}

Desmontaje:

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

Answer 4

Tiene expresiones no triviales en el lado izquierdo de = que deben evaluarse todo el tiempo. Aquí hay unos ejemplos.

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!

Answer 5

Un "operando de la izquierda" puede ser mucho más complicado que su simple x en su ejemplo (lo que, ciertamente, no es un desafío para evaluar):

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

Definitivamente necesita un poco de evaluación en el LHS. Su oración citada se refiere a lo que debe hacerse en el lado izquierdo de la tarea para encontrar el valor apropiado para recibir la tarea.