¿Qué es x después de "x = x ++"?

¿Qué sucede (detrás de las cortinas) cuando se ejecuta esto?

int x = 7;
x = x++;

Es decir, cuando una variable se incrementa y se asigna a sí misma en una declaración? Compilé y ejecuté esto. xsigue siendo 7 incluso después de toda la declaración . En mi libro, dice que xse incrementa!

xse incrementa. Pero está asignando el antiguo valor de xvolver a sí mismo.

x = x++;

1. x++incrementa xy devuelve su valor anterior.
2. x = asigna el antiguo valor de nuevo a sí mismo.

Entonces, al final, xse le asigna de nuevo a su valor inicial.

x = x++;

es equivalente a

int tmp = x;
x++;
x = tmp;

La declaración:

x = x++;

es equivalente a:

tmp = x;   // ... this is capturing the value of "x++"
x = x + 1; // ... this is the effect of the increment operation in "x++" which
           //     happens after the value is captured.
x = tmp;   // ... this is the effect of assignment operation which is
           //     (unfortunately) clobbering the incremented value.

En resumen, la declaración no tiene ningún efecto.

Los puntos clave:

• El valor de una expresión de incremento / decremento de Postfix es el valor del operando antes de que tenga lugar el incremento / decremento. (En el caso de un formulario de Prefijo, el valor es el valor del operando después de la operación)

• el RHS de una expresión de asignación se evalúa por completo (incluidos los incrementos, decrementos y / u otros efectos secundarios) antes de asignar el valor al LHS.

_{Tenga en cuenta que, a diferencia de C y C ++, el orden de evaluación de una expresión en Java está totalmente especificado y no hay espacio para la variación específica de la plataforma. Los compiladores solo pueden reordenar las operaciones si esto no cambia el resultado de ejecutar el código desde la perspectiva del hilo actual. En este caso, a un compilador se le permitiría optimizar la declaración completa porque se puede demostrar que no funciona.}

En caso de que no sea ya obvio:

• "x = x ++;" es casi seguro un error en cualquier programa.
• El OP (¡para la pregunta original!) Probablemente significaba "x ++;" en lugar de "x = x ++;".
• Las declaraciones que combinan auto inc / decrement y asignación en la misma variable son difíciles de entender y, por lo tanto, deben evitarse independientemente de su corrección . Simplemente no hay necesidad de escribir código como ese.

Con suerte, los verificadores de códigos como FindBugs y PMD marcarán códigos como este como sospechosos.

int x = 7;
x = x++;

Tiene un comportamiento indefinido en C y para Java vea esta respuesta . Depende del compilador lo que suceda.

Una construcción como x = x++;indica que probablemente estás malinterpretando lo ++que hace el operador:

// original code
int x = 7;
x = x++;

Reescribamos esto para hacer lo mismo, basándonos en eliminar el ++operador:

// behaves the same as the original code
int x = 7;
int tmp = x; // value of tmp here is 7
x = x + 1; // x temporarily equals 8 (this is the evaluation of ++)
x = tmp; // oops! we overwrote y with 7

Ahora, reescribamos para hacer (lo que creo) que querías:

// original code
int x = 7;
x++;

La sutileza aquí es que el ++operador modifica la variablex , a diferencia de una expresión como x + x, que evaluaría a un valor int pero dejaría la variable en xsí misma sin cambios. Considere una construcción como el venerable forbucle:

for(int i = 0; i < 10; i++)
{
    System.out.println(i);
}

Observe el i++de allí? Es el mismo operador. Podríamos reescribir este forbucle así y se comportaría igual:

for(int i = 0; i < 10; i = i + 1)
{
    System.out.println(i);
}

También recomiendo no usar el ++operador en expresiones más grandes en la mayoría de los casos. Debido a la sutileza de cuando modifica la variable original en el incremento previo versus posterior ( ++xy x++, respectivamente), es muy fácil introducir errores sutiles que son difíciles de rastrear.

Según el código de bytes obtenido de los archivos de clase,

Ambas asignaciones incrementan x, pero la diferencia es el tiempo de when the value is pushed onto the stack

En Case1, Push ocurre (y luego se asigna) antes del incremento (esencialmente significa que su incremento no hace nada)

En Case2, el incremento ocurre primero (convirtiéndolo en 8) y luego empujado a la pila (y luego asignado a x)

Caso 1:

int x=7;
x=x++;

Código de bytes:

0  bipush 7     //Push 7 onto  stack
2  istore_1 [x] //Pop  7 and store in x
3  iload_1  [x] //Push 7 onto stack
4  iinc 1 1 [x] //Increment x by 1 (x=8)
7  istore_1 [x] //Pop 7 and store in x
8  return       //x now has 7

Caso 2:

int x=7; 
x=++x;

Código de bytes

0  bipush 7     //Push 7 onto stack
2  istore_1 [x] //Pop 7 and store in x
3  iinc 1 1 [x] //Increment x by 1 (x=8)
6  iload_1  [x] //Push x onto stack
7  istore_1 [x] //Pop 8 and store in x
8  return       //x now has 8

• La pila aquí se refiere a la pila de operandos, local: índice x: 1 tipo: int

Se incrementa después de " x = x++;". Sería 8 si lo hicieras " x = ++x;".

El operador de incremento posterior funciona de la siguiente manera:

1. Almacenar el valor anterior del operando.
2. Incremente el valor del operando.
3. Devuelve el valor anterior del operando.

Entonces la declaración

int x = 7;
x = x++; 

se evaluaría de la siguiente manera:

1. x se inicializa con el valor 7
2. El operador de incremento posterior almacena el valor anterior de x, es decir, 7 para devolver.
3. Incrementa la x, así que ahora x es 8
4. Devuelve el valor anterior de x, es decir, 7 y se asigna de nuevo a x, por lo que x vuelve a ser 7

Por lo tanto, x aumenta, pero dado que x ++ está asignando el resultado nuevamente a x, el valor de x se anula a su valor anterior.

El incremento ocurre después de que se llama x, por lo que x todavía es igual a 7. ++ x sería igual a 8 cuando se llama x

Cuando reasigne el valor x, todavía es 7. Pruebe x = ++xy obtendrá 8 más.

x++; // don't re-assign, just increment
System.out.println(x); // prints 8

porque x ++ incrementa el valor DESPUÉS de asignarlo a la variable. etc. y durante la ejecución de esta línea:

x++;

la varialbe x seguirá teniendo el valor original (7), pero usando x nuevamente en otra línea, como

System.out.println(x + "");

te dará 8.

si desea usar un valor incrementado de x en su declaración de asignación, use

++x;

Esto incrementará x en 1, ENTONCES asigne ese valor a la variable x.

[Editar] en lugar de x = x ++, es solo x ++; el primero asigna el valor original de x a sí mismo, por lo que en realidad no hace nada en esa línea.

¿Qué pasa cuando int x = 7; x = x++;?

ans -> x++significa el primer valor de uso de x para la expresión y luego aumentarlo en 1.
Esto es lo que sucede en su caso. El valor de x en RHS se copia en la variable x en LHS y luego el valor de xse incrementa en 1.

Del mismo modo ++x significa ->aumentar el valor de x primero en uno y luego usarlo en la expresión.
Entonces, en su caso, si lo hace x = ++x ; // where x = 7
, obtendrá un valor de 8.

Para mayor claridad, intente averiguar cuántas sentencias printf ejecutarán el siguiente código

while(i++ <5)   
  printf("%d" , ++i);   // This might clear your concept upto  great extend

++xes pre-incremento ->x se incrementa antes de ser usado
x++es post-incremento ->x se incrementa después de ser usado

int x = 7; -> x get 7 value <br>
x = x++; -> x get x value AND only then x is incremented

Entonces esto significa: x++no es igual ax = x+1

porque:

int x = 7; x = x++;
x is 7

int x = 7; x = x = x+1;
x is 8

y ahora parece un poco extraño:

int x = 7; x = x+=1;
x is 8

muy dependiente del compilador!

x = x ++;

Este es el operador posterior al incremento. Debe entenderse como "Usar el valor del operando y luego incrementar el operando".

Si desea que ocurra lo contrario, es decir, "Incremente el operando y luego use el valor del operando", debe usar el operador de incremento previo como se muestra a continuación.

x = ++ x;

Este operador primero incrementa el valor de x en 1 y luego asigna el valor nuevamente a x.

Creo que esta controversia se puede resolver sin entrar en código y solo pensar.

Considere i ++ y ++ i como funciones, digamos Func1 y Func2.

Ahora i = 7;
Func1 (i ++) devuelve 7, Func2 (++ i) devuelve 8 (todo el mundo lo sabe). Internamente, ambas funciones aumentan de i a 8, pero devuelven valores diferentes.

Entonces i = i ++ llama a la función Func1. Dentro de la función i se incrementa a 8, pero al finalizar la función devuelve 7.

Entonces, en última instancia, 7 se asigna a i. (Entonces, al final, i = 7)

Esto se debe a que utilizó un operador posterior al incremento. En esta siguiente línea de código

x = x++;

Lo que sucede es que estás asignando el valor de x a x. x ++ incrementa x después de que el valor de x se asigna a x. Así es como funcionan los operadores posteriores al incremento. Funcionan después de que se haya ejecutado una declaración. Entonces, en su código, x se devuelve primero después y luego se incrementa.

Si lo hiciste

x = ++x;

La respuesta sería 8 porque usó el operador de pre-incremento. Esto incrementa el valor primero antes de devolver el valor de x.