¿Cuál es la diferencia entre el preincremento y el incremento posterior en el ciclo (durante / mientras)?

Mi interés está en la diferencia entre for y while loops. Sé que el valor posterior al incremento se usa y luego se incrementa y la operación devuelve un pre-incremento constante.

 while (true) { //... i++; int j = i; } 

Aquí, ¿ j contendrá el i viejo o el i incrementado al final del ciclo?

Dado que la statement i ++ termina en el ; en su ejemplo, no importa si utiliza el incremento previo o posterior.

La diferencia surge cuando utilizas el resultado:

 int j = i++; // i will contain i_old + 1, j will contain the i_old. 

Vs:

 int j = ++i; // i and j will both contain i_old + 1. 

Depende de cómo los uses.

  • i++ hace una copia, aumenta iy devuelve la copia (valor anterior).
  • ++i aumenta i, y devuelve i.

En tu ejemplo, todo se trata de velocidad. ++i más rápido que i++ ya que no hace una copia.

Sin embargo, un comstackdor probablemente lo optimizará, ya que no está almacenando el valor devuelto por el operador de incremento en su ejemplo, pero esto solo es posible para tipos fundamentales como un int .

Respuesta básica para entender. El operador de incremento funciona así:

 // ++i function pre_increment(i) { i += 1; return i; } // i++ function post_increment(i) { copy = i; i += 1; return copy; } 

Un buen comstackdor reemplazará automáticamente i++ con ++i cuando detecte que el valor devuelto no se utilizará.

En Pre-Incremento, el valor inicial primero se incrementa y luego se usa dentro de la expresión.

 a=++i; 

En este ejemplo, supongamos que el valor de la variable i es 5, entonces el valor de la variable a será 6 porque, el valor de i se modifica antes de usarlo en una expresión.

En el valor posterior al incremento se usa por primera vez en una expresión y luego se incrementa.

 a=i++; 

En este ejemplo, supongamos que el valor de la variable i es 5, entonces el valor de la variable a será 5 porque el valor de i se incrementa solo después de asignar el valor 5 a a .

 #include  #include  int main(int argc, char **argp) { int x = 5; printf("x=%d\n", ++x); printf("x=%d\n", x++); printf("x=%d\n", x); return EXIT_SUCCESS; } 

Salida del progtwig:

 x=6 x=6 x=7 

En la primera instrucción printf, x se incrementa antes de pasarse a printf para que se emita el valor 6, en la segunda x pasa a printf (por lo que se emite 6) y luego se incrementa y la tercera instrucción printf solo muestra ese incremento posterior al anterior statement al generar x nuevamente que ahora tiene el valor 7.

i ++ usa el valor de i luego lo incrementa, pero ++ aumenta el valor de i antes de usarlo.

La diferencia entre el incremento posterior y previo es realmente, en muchos casos sutil. post incremenet, también conocido como num++ , primero crea una copia de num , la devuelve y, a continuación , la incrementa. El preincremento, por otro lado, aka ++num , primero evalúa y luego devuelve el valor. La mayoría de los comstackdores modernos, al ver esto en un bucle, generalmente se optimizarán, principalmente cuando se usa el incremento posterior, y no se usa el valor inicial devuelto. La diferencia más importante entre los 2 incrementos, donde es muy común crear errores sutiles, es cuando se declaran variables, con valores incrementados: Ejemplo a continuación:

 int num = 5; int num2 = ++num; //Here, first num is incremented, //then made 6, and that value is stored in num2; 

Otro ejemplo:

 int num = 5; int num2 = num++; //Here, num is first returned, (unfortunately?), and then //incremented. This is useful for some cases. 

Lo último que quiero decir aquí es CUIDADO CON INCREMENTOS . Al declarar variables, asegúrese de usar el incremento correcto, o simplemente escriba todo ( num2 = num + 1 , que no siempre funciona, y es el equivalente al preincremento). Se ahorrarán muchos problemas si usa el incremento correcto.