c# - programacion - que significa i++ en c++

En C#, ¿cuál es la diferencia entre myInt++ y++ myInt?

Question

Estoy teniendo dificultades para entender cuál es la diferencia entre incrementar una variable en C # de esta manera:

myInt++;

y

++myInt;

¿Cuándo importaría cuál usas?

Daré voteCount ++ por la mejor respuesta. O debería darle ++ voteCount ...

Answer 1

++ myInt agregará uno a myInt antes de ejecutar la línea en cuestión, myInt ++ lo hará después.

Ejemplos:

int myInt;
myInt = 1;
someFunction(++myInt); // Sends 2 as the parameter
myInt = 1;
someFunction(myInt++); // Sends 1 as the parameter

Answer 2

Creo que es más simple de entender en términos del orden de evaluación y modificación .

• El operador postfix (x ++) evalúa primero y modifica el último.
• El operador de prefijo (++ x) se modifica primero y evalúa el último.

(el orden de las operaciones es evidente en el orden tipeado del operador y la variable)

Es decir, cuando se usa en una expresión, el operador de posfijo evalúa y usa el valor actual de la variable en la expresión (una declaración de retorno o una llamada a un método) antes de aplicar el operador. Con el operador de prefijo, es al revés.

Answer 3

Determina cuándo se devuelve el resultado de esa operación.

Aquí hay un ejemplo del sitio de MSDN :

static void Main()
{
double x;
x = 1.5;
Console.WriteLine(++x);
x = 1.5;
Console.WriteLine(x++);
Console.WriteLine(x);
}

Y la salida:

2.5
1.5
2.5

Answer 4

El operador de preparación previa ++ myInt es una forma de reducir líneas: incremente la variable antes de pasarla a otro lugar. También es una buena manera de reducir la legibilidad, ya que es poco común.

MyMethod(++myInt); 

vs.

myInt++;
MyMethod(myInt);

Para mí, el segundo es mucho más fácil de leer.

Answer 5

En asignación o expresiones, por ejemplo

x = ++myInt; // x = myInt + 1
x = myInt++; // x = myInt

Esto también se puede usar en expresiones como para bucles o declaraciones if. Por ejemplo, tome lo siguiente donde seek es 0 y count es 3.

while(seek++ < count) {
Console.WriteLine(seek);
}

da como resultado salidas de 1, 2 y 3, para buscar y lo siguiente

while(++seek < count) {
Console.WriteLine(seek);
}

Resultados en 1 y 2 para buscar. Entonces ++ myInt incrementa myInt antes de que se evalúe su valor, mientras que myInt ++ se incrementa después de que se evalúa.

Answer 6

Es una diferencia si estás haciendo

int x = 7;
int x2 = x++;
=> x2 is 7 and x is 8

pero al hacer

int x = 7;
int x2 = ++x;
=> x2 is 8 and x is 8

Answer 7

No lo hace a menos que esté en una expresión, es decir,

myInt=1;
x=myInt++;

es diferente a:

myInt=1;
x=++myInt;

El primero asigna 1 a x, porque la asignación ocurre antes del incremento.

El segundo asigna 2 a x, porque la asignación ocurre después del incremento.

Answer 8

Otros han mostrado dónde marca la diferencia y han comentado que, como única declaración, no hace la diferencia.

Me gustaría agregar que casi siempre es una mala idea usarlo donde hace la diferencia. Sospecho que en algunas ocasiones es más legible tener un código como:

Console.WriteLine("Foo: {0}", foo++);

que:

Console.WriteLine("Foo: {0}", foo);
foo++;

... ¡pero son muy raros! La última de estas dos muestras hace que el orden sea claro como el cristal inmediatamente; el primero requiere un poco de reflexión (para mi pobre cerebro, de todos modos). Piensa en la legibilidad primero.

Answer 9

Si, por ejemplo, haces algo como esto:

int myInt = 5;
Foo(++myInt);
void Foo(int x)
{
Console.WriteLine(x);
}

Esto se imprimirá 6.

Foo(myInt++);

se imprimirá 5;

Básicamente, ++ myInt incrementa PRIMERO usa la variable SEGUNDO. myInt ++ es lo opuesto.

Answer 10

myInt ++ (4 instrucciones de CPU)

LOAD AX, #myInt // From myInt memory to a CPU register
COPY AX, BX
INCREMENT BX
STORE BX, #myInt
// Use AX register for the value

++ myInt (3 instrucciones de CPU)

LOAD AX, #myInt // From myInt memory to a CPU register
INCREMENT AX
STORE AX, #myInt
// Use AX register for the value

Answer 11

No hay diferencia cuando se escribe por sí mismo (como se muestra): en ambos casos, myInt se incrementará en 1.

Pero hay una diferencia cuando lo usa en una expresión, por ejemplo, algo como esto:

MyFunction(++myInt);
MyFunction(myInt++);

En el primer caso, myInt se incrementa y el valor nuevo / incrementado se pasa a MyFunction (). En el segundo caso, el antiguo valor de myInt pasa a MyFunction () (pero myInt aún se incrementa antes de que se llame a la función).

Otro ejemplo es esto:

int myInt = 1;
int a = ++myInt;
// myInt is incremented by one and then assigned to a.
// Both myInt and a are now 2.
int b = myInt++;
// myInt is assigned to b and then incremented by one.
// b is now 2, myInt is now 3

Por cierto: como Don señaló en un comentario, las mismas reglas también son válidas para las operaciones de disminución, y la terminología correcta para estas operaciones es:

++i; // pre-increment
i++; // post-increment
--i; // pre-decrement
i--; // post-decrement

Como Jon Skeet señala:

Otros han mostrado dónde marca la diferencia y han comentado que, como única declaración, no hace la diferencia.

Me gustaría agregar que casi siempre es una mala idea usarlo donde hace la diferencia. Sospecho que en algunas ocasiones es más legible tener un código como:

Console.WriteLine("Foo: {0}", foo++);

que:

Console.WriteLine("Foo: {0}", foo);
foo++; 

... ¡pero son muy raros! La última de estas dos muestras hace que el orden sea claro como el cristal inmediatamente; el primero requiere un poco de reflexión (para mi pobre cerebro, de todos modos). Piensa en la legibilidad primero.