uso - suma+= c#

C#confusiones de pre y post incremento

Question

Estoy un poco confundido acerca de cómo el compilador C # maneja los incrementos y decrementos previos y posteriores.

Cuando codigo lo siguiente:

int x = 4;
x = x++ + ++x;

x tendrá el valor 10 después. Creo que esto se debe a que el pre-incremento establece x a 5 , lo que lo convierte en 5+5 que evalúa a 10 . Luego, el incremento posterior actualizará de x a 6 , pero este valor no se usará porque 10 se asignará a x .

Pero cuando codigo:

int x = 4;
x = x-- - --x;

entonces x será 2 después. ¿Alguien puede explicar por qué este es el caso?

Answer 1

Creo que la explicación para el caso ++ ++ ++ es incorrecta:

comando ........... valor de x

.................. undefined

int x = 4 .......... 4

x ++ ............... 5 (el primer summand es 4)

++ x ............... 6 (segundo summand es 6)

x = summand1 + summand2 ..4 + 6 = 10

Análogamente, la explicación del - - - caso es

comando ........... valor de x

.................. undefined

int x = 4 .......... 4

x --............... 3 (el subtactor es 4)

--x ............... 2 (sustraendo es 2)

x = resta-restar ..4-2 = 10

Answer 2

De tu comentario:

Pensé que los incrementos posteriores y previos se ejecutan después de / antes de la evaluación de la línea de código completa, pero se ejecutan después / antes de la evaluación de cada elemento en la expresión.

Tu malentendido es muy común. Tenga en cuenta que en algunos idiomas, como C, no se especifica cuando el efecto secundario se vuelve visible y, por lo tanto, es legal, pero no obligatorio, que su declaración sea verdadera en C.

Este no es el caso en C #; en C # , los efectos secundarios del código en el lado izquierdo de una expresión siempre se observan antes de que se ejecute el código en el lado derecho (desde un único hilo, en escenarios multiproceso, todas las apuestas están desactivadas).

Para una explicación más detallada de lo que hacen los operadores de incremento en C #, ver:

¿Cuál es la diferencia entre i ++ y ++ i?

Hay una gran cantidad de enlaces adicionales a los artículos que he escrito sobre este tema a menudo incomprendido.

Answer 3

Echemos un vistazo a la IL que se genera a partir de esa declaración

IL_0002: ldloc.0

Carga el valor de x en la pila. Pila => (4)

IL_0003: dup

Duplica el elemento superior en la pila. Pila => (4, 4)

IL_0004: ldc.i4.1

Presione 1 en la pila. Pila => (1, 4, 4)

IL_0005: sub

Reste los dos valores superiores e inserte el resultado en la pila. Pila => (3, 4)

IL_0006: stloc.0

Guarde el valor superior de la pila en x. Pila => (4)

IL_0007: ldloc.0

Cargue el valor de x en la pila. Pila => (3, 4)

IL_0008: ldc.i4.1

Cargue el valor 1 en la pila. Pila => (1, 3, 4)

IL_0009: sub

Reste los dos. Pila => (2, 4)

IL_000A: dup

Duplicar el valor superior => (2, 2, 4)

IL_000B: stloc.0

Almacene el valor superior de nuevo en x. Pila => (2, 4)

IL_000C: sub

Reste los dos valores superiores. Pila => (2)

IL_000D: stloc.0

Guarde este valor nuevamente en x. x == 2

Answer 4

En este ejemplo,

int x = 4;
x = x++ + ++x;

puedes romperlo así:

x = 4++; which is = 5
x = 4 + ++5; which is 4 + 6
x = 10

Similar,

int x = 4;
x = x-- - --x;

Aquí,

x = 4--; which is = 3
x = 4 - --3; which is 4 - 2
x = 2

Simplemente poniendo puedes decir, reemplaza el valor actual de x, pero por cada ++ o - suma / resta un valor de x.

Answer 5

Lo más interesante es que obtendrás una respuesta completamente diferente con el compilador C ++. Net.

int x = 4;
x = x++ + ++x; // x = 11
x = 4;
x = x-- - --x; // x = -1

Por supuesto, la diferencia en los resultados está determinada por semántica diferente, parece normal. Pero a pesar del entendimiento, el hecho de que dos compiladores de .net no se comporten de manera similar para tales cosas básicas también me confunde.

Answer 6

x-- será 4, pero será 3 en el momento de --x , entonces terminará siendo 2, entonces tendrás

x = 4 - 2

por cierto, tu primer caso será x = 4 + 6

Aquí hay un pequeño ejemplo que imprimirá los valores de cada parte, quizás de esta manera lo entenderá mejor:

static void Main(string[] args)
{
int x = 4;
Console.WriteLine("x++: {0}", x++); //after this statement x = 5
Console.WriteLine("++x: {0}", ++x);
int y = 4;
Console.WriteLine("y--: {0}", y--); //after this statement y = 3
Console.WriteLine("--y: {0}", --y);
Console.ReadKey();
}

esto se imprime

x++: 4
++x: 6
y--: 4
--y: 2