despues - diferencia entre a++ y++ a java

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

Question

¿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. x sigue siendo 7 incluso después de toda la declaración . En mi libro, dice que x se incrementa!

Answer 1

¿Qué sucede cuando int x = 7; x = x++; 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 pasa en tu caso. El valor de x en RHS se copia en la variable x en LHS y luego el valor de x se incrementa en 1.

De manera similar, ++x significa -> aumentar el valor de x primero en uno y luego usar en expresión.
Así que en tu caso si haces x = ++x ; // where x = 7 x = ++x ; // where x = 7
Obtendrá valor de 8.

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

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

Answer 2

Creo que esta controversia puede resolverse sin entrar en el código y solo pensar.

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

Ahora i = 7;
Func1 (i ++) devuelve 7, Func2 (++ i) devuelve 8 (todo el mundo lo sabe). Internamente, ambas funciones incrementan 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.

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

Answer 3

Cuando reasignas el valor para x , sigue siendo 7. Intenta x = ++x y obtendrás 8 si no lo haces

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

Answer 4

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

Answer 5

El operador de Incremento de Publicaciones funciona de la siguiente manera:

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

Así que la declaración

int x = 7;
x = x++; 

se evaluaría de la siguiente manera:

1. x se inicializa con valor 7
2. El operador de incremento posterior almacena el valor anterior de x, es decir, 7 para devolver.
3. Incrementa la x, entonces 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

Entonces, x realmente se incrementa, pero como x ++ está asignando el resultado de nuevo a x, el valor de x se anula a su valor anterior.

Answer 6

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

x = x++;

Lo que pasa 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 post-incremento. Funcionan después de que se ha ejecutado una declaración. Por lo tanto, en su código, x se devuelve primero, luego se incrementa.

Si lo hiciste

x = ++x;

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

Answer 7

Esto significa que: x++ no es igual a x = 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!

Answer 8

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 afirmación no tiene 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 una forma de prefijo, el valor es el valor del operando después de la operación)

• La RHS de una expresión de asignación se evalúa por completo (incluidos los incrementos, disminuciones y / u otros efectos secundarios) antes de que el valor se asigne a la 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 subproceso actual. En este caso, a un compilador se le permitiría optimizar la declaración completa porque se puede probar que es un no-op.}

En caso de que no sea ya obvio:

• "x = x ++;" Es casi seguro que es un error en cualquier programa.
• El OP (para la pregunta original) probablemente significaba "x ++;" en lugar de "x = x ++;".
• Las declaraciones que combinan inc / decremento automático 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 este código como sospechoso.

Answer 9

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

Answer 10

Una construcción como x = x++; indica que probablemente no entiendas lo que hace el operador ++ :

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

Reescribamos esto para hacer lo mismo, basado 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, reescribámoslo para hacer (lo que creo) que querías:

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

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

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

Observe el i++ allí? Es el mismo operador. Podríamos reescribir esto for bucle como este 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 pre- versus post-increment ( ++x y x++ , respectivamente), es muy fácil introducir errores sutiles que son difíciles de localizar.

Answer 11

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

x++;

el varialbe x seguirá teniendo el valor original (7), pero utilizando x de nuevo 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 por 1, y luego asignará 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.

Answer 12

x = x ++;

Este es el operador post-incremento. Debe entenderse como "Use el valor del operando y luego incremente 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 preincremento como se muestra a continuación.

x = ++ x;

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

Answer 13

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

Ambas asignaciones aumentan x, pero la diferencia es la sincronización de when the value is pushed onto the stack

En el Case1 , el Empuje ocurre (y luego se asigna) antes del incremento (lo que significa que su incremento no hace nada)

En el Case2 , el incremento se produce primero (haciéndolo 8) y luego se empuja en la pila (y luego se asigna 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 byte

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

Answer 14

++x es 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

Answer 15

x se incrementa. Pero estás asignando el antiguo valor de x nuevo a sí mismo.

x = x++;

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

Así que al final, x se asigna de nuevo a su valor inicial.

Answer 16

int x = 7;
x = x++;

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

Answer 17

x = x++;

es equivalente a

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