Después de investigar en diversos repositorios y páginas al final nos hemos encontrado la resolución que te mostramos más adelante.
Solución:
a++ se conoce como sufijo.
sumar 1 a a, devuelve el valor anterior.
++a se conoce como prefix.
sumar 1 a a, devuelve el nuevo valor.
C#:
string[] items = "a","b","c","d";
int i = 0;
foreach (string item in items)
Console.WriteLine(++i);
Console.WriteLine("");
i = 0;
foreach (string item in items)
Console.WriteLine(i++);
Producción:
1
2
3
4
0
1
2
3
foreach y while los bucles dependen del tipo de incremento que utilice. Con bucles for como el siguiente, no hay diferencia ya que no está utilizando el valor de retorno de i:
for (int i = 0; i < 5; i++) Console.Write(i);
Console.WriteLine("");
for (int i = 0; i < 5; ++i) Console.Write(i);
0 1 2 3 4
0 1 2 3 4
Si se usa el valor evaluado, entonces el tipo de incremento se vuelve significativo:
int n = 0;
for (int i = 0; n < 5; n = i++)
Pre-incremento ++i incrementa el valor de i y evalúa el nuevo valor incrementado.
int i = 3;
int preIncrementResult = ++i;
Assert( preIncrementResult == 4 );
Assert( i == 4 );
Post-incremento i++ incrementa el valor de i y se evalúa al valor original no incrementado.
int i = 3;
int postIncrementResult = i++;
Assert( postIncrementtResult == 3 );
Assert( i == 4 );
En C++, generalmente se prefiere el incremento previo donde puede usar cualquiera.
Esto se debe a que si usa el incremento posterior, puede requerir que el compilador tenga que generar código que cree una variable temporal adicional. Esto se debe a que tanto el valor anterior como el nuevo de la variable que se incrementa deben mantenerse en algún lugar porque pueden ser necesarios en otra parte de la expresión que se evalúa.
Entonces, al menos en C ++, puede haber una diferencia de rendimiento que guíe su elección de cuál usar.
Esto es principalmente solo un problema cuando la variable que se incrementa es un tipo definido por el usuario con un operador ++ anulado. Para tipos primitivos (int, etc.) no hay diferencia de rendimiento. Pero vale la pena ceñirse al operador de incremento previo como guía, a menos que el operador de incremento posterior sea definitivamente lo que se requiere.
Hay algo más de discusión aquí.
En C ++, si está usando STL, entonces puede estar usando bucles for con iteradores. Estos tienen principalmente operadores ++ anulados, por lo que es una buena idea ceñirse al incremento previo. Sin embargo, los compiladores se vuelven más inteligentes todo el tiempo, y los más nuevos pueden realizar optimizaciones que significan que no hay diferencia de rendimiento, especialmente si el tipo que se incrementa se define en línea en el archivo de encabezado (como lo son a menudo las implementaciones STL) para que el compilador pueda ver cómo el método se implementa y luego puede saber qué optimizaciones son seguras de realizar. Aun así, probablemente valga la pena apegarse al incremento previo porque los bucles se ejecutan muchas veces y esto significa que pronto podría amplificarse una pequeña penalización en el rendimiento.
En otros lenguajes, como C#, donde el operador ++ no se puede sobrecargar, no hay diferencia de rendimiento. Usados en un ciclo para avanzar la variable del ciclo, los operadores de incremento previo y posterior son equivalentes.
Corrección: se permite sobrecargar ++ en C#. Sin embargo, parece que, en comparación con C ++, en C # no puede sobrecargar las versiones anteriores y posteriores de forma independiente. Por lo tanto, asumiría que si el resultado de llamar a ++ en C# no se asigna a una variable o no se usa como parte de una expresión compleja, entonces el compilador reduciría las versiones anteriores y posteriores de ++ a un código que funciona de manera equivalente.
En C# no hay diferencia cuando se usa en un bucle for.
for (int i = 0; i < 10; i++) Console.WriteLine(i);
sale lo mismo que
for (int i = 0; i < 10; ++i) Console.WriteLine(i);
Como han señalado otros, cuando se usan en general, i++ y ++i tienen una diferencia sutil pero significativa:
int i = 0;
Console.WriteLine(i++); // Prints 0
int j = 0;
Console.WriteLine(++j); // Prints 1
i++ lee el valor de i y luego lo incrementa.
++i incrementa el valor de i y luego lo lee.
valoraciones y reseñas
Si te ha resultado de ayuda nuestro post, sería de mucha ayuda si lo compartes con el resto entusiastas de la programación de esta manera contrubuyes a difundir este contenido.