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

En C, ¿cuál es la diferencia entre usar ++i e i++ , y cuál debería usarse en el bloque de incremento de un bucle for ?

  • ++i boosté el valor de i , y luego devolveré el valor incrementado.

      i = 1; j = ++i; (i is 2, j is 2) 
  • i++ incrementará el valor de i , pero devolverá el valor original que tenía antes de ser incrementado.

      i = 1; j = i++; (i is 2, j is 1) 

Para un bucle for , cualquiera de los dos funciona. ++i Parece más común, tal vez porque eso es lo que se usa en K & R.

En cualquier caso, siga la pauta “prefiera ++i sobre i++ ” y no se equivocará.

Hay un par de comentarios sobre la eficiencia de ++i i++ . En cualquier comstackdor que no sea de proyecto de estudiante, no habrá diferencia de rendimiento. Puede verificar esto mirando el código generado, que será idéntico.

La cuestión de la eficiencia es interesante … aquí está mi bash de respuesta: ¿hay una diferencia de rendimiento entre i ++ y ++ i en C?

Como en las notas de Freund , es diferente para un objeto de C ++, ya que el operator++() es una función y el comstackdor no puede saber para optimizar la creación de un objeto temporal para mantener el valor intermedio.

i ++ se conoce como Incremento de publicación, mientras que ++ i se llama Pre Incremento.

i++

i++ es un incremento posterior porque aumenta el valor de i en 1 después de que la operación finaliza.

Veamos el siguiente ejemplo:

 int i = 1, j; j = i++; 

Aquí el valor de j = 1 pero i = 2 . Aquí el valor de i se asignará a j primero y luego boosté.

++i

++i es un incremento previo porque aumenta el valor de i en 1 antes de la operación. Significa j = i; se ejecutará después de i++ .

Veamos el siguiente ejemplo:

 int i = 1, j; j = ++i; 

Aquí el valor de j = 2 pero i = 2 . Aquí el valor de i se asignará a j después del aumento de i . De forma similar ++i se ejecutará antes de j=i; .

Para su pregunta, ¿ cuál debería usarse en el bloque de incremento de un ciclo for? la respuesta es que puedes usar cualquiera … no importa. Ejecutará su bucle for igual no. de veces

 for(i=0; i<5; i++) printf("%d ",i); 

Y

 for(i=0; i<5; ++i) printf("%d ",i); 

Ambos bucles producirán la misma salida. es decir, 0 1 2 3 4 .

Solo importa dónde lo estás usando.

 for(i = 0; i<5;) printf("%d ",++i); 

En este caso, la salida será 1 2 3 4 5 .

Por favor, no te preocupes por la “eficiencia” (velocidad, en realidad) de la que uno es más rápido. Tenemos comstackdores en estos días que se ocupan de estas cosas. Use cualquiera que tenga sentido usar, según lo que muestre más claramente su intención.

++i incrementa el valor, luego lo devuelve.

i++ devuelve el valor y luego lo incrementa.

Es una diferencia sutil.

Para un bucle for, use ++i , ya que es un poco más rápido. i++ creará una copia adicional que simplemente se descarta.

i ++: – En este escenario, primero se asigna el valor y luego ocurre el incremento.

++ i: – En este escenario, primero se realiza el incremento y luego se asigna el valor

A continuación se muestra la visualización de la imagen y también aquí hay un buen video práctico ( http://www.youtube.com/watch?v=lrtcfgbUXm4 ) que demuestra lo mismo.

enter image description here

La razón por la que ++i puede ser un poco más rápido que i++ es que i++ puede requerir una copia local del valor de i antes de que se incremente, mientras que ++i nunca lo hace. En algunos casos, algunos comstackdores lo optimizarán si es posible … pero no siempre es posible, y no todos los comstackdores lo hacen.

Intento no confiar demasiado en las optimizaciones de los comstackdores, así que seguiría el consejo de Ryan Fox: cuando puedo usar ambas, utilizo ++i .

El resultado efectivo de usar cualquiera es idéntico. En otras palabras, el ciclo hará exactamente lo mismo en ambos casos.

En términos de eficiencia, podría haber una penalización relacionada con la elección de i ++ sobre ++ i. En términos de la especificación del idioma, el operador de post-incremento debe crear una copia adicional del valor en el que actúa el operador. Esto podría ser una fuente de operaciones adicionales.

Sin embargo, debe considerar dos problemas principales con la lógica anterior.

  1. Los comstackdores modernos son geniales. Todos los buenos comstackdores son lo suficientemente inteligentes como para darse cuenta de que están viendo un incremento de enteros en for-loop, y optimizarán ambos métodos con el mismo código eficiente. Si usar el incremento posterior al preincremento en realidad hace que su progtwig tenga un tiempo de ejecución más lento, entonces está utilizando un comstackdor terrible .

  2. En términos de complejidad de tiempo operacional, los dos métodos (incluso si se está realizando una copia) son equivalentes. El número de instrucciones que se realizan dentro del ciclo debe dominar significativamente el número de operaciones en la operación de incremento. Por lo tanto, en cualquier bucle de tamaño significativo, la penalización del método de incremento quedará ensombrecida de forma masiva por la ejecución del cuerpo del bucle. En otras palabras, es mucho mejor que te preocupes por optimizar el código en el ciclo en lugar del incremento.

En mi opinión, todo el tema simplemente se reduce a una preferencia de estilo. Si crees que el pre-incremento es más legible, entonces úsalo. Personalmente, prefiero el post-proceso, pero probablemente sea porque fue lo que me enseñaron antes de saber nada sobre la optimización.

Este es un ejemplo por excelencia de optimización prematura, y problemas como este tienen el potencial de distraernos de problemas serios en el diseño. Sin embargo, es una buena pregunta, porque no hay uniformidad en el uso o el consenso en las “mejores prácticas”.

Ambos incrementan el número. ++ i es equivalente a i = i + 1.

i ++ y ++ i son muy similares pero no exactamente iguales. Ambos incrementan el número, pero ++ incrementa el número antes de que se evalúe la expresión actual, mientras que i ++ incrementa el número después de evaluar la expresión.

Ejemplo:

 int i = 1; int x = i++; //x is 1, i is 2 int y = ++i; //y is 3, i is 3 

++ i es pre-incremento el otro es post-incremento

i ++: obtiene el elemento y luego lo incrementa.
++ i: incrementa i y luego devuelve el elemento

Ejemplo:

 int i = 0; printf("i: %d\n", i); printf("i++: %d\n", i++); printf("++i: %d\n", ++i); 

Salida:

 i: 0 i++: 0 ++i: 2 

++ i (operación de prefijo): aumenta y luego asigna el valor
(por ejemplo): int i = 5, int b = ++ i
En este caso, 6 se asigna a b primero y luego se incrementa a 7 y así sucesivamente.

i ++ (operación Postfix): asigna y luego incrementa el valor
(por ejemplo): int i = 5, int b = i ++
En este caso, 5 se asigna a b primero y luego a 6 y así sucesivamente.

En caso de bucle for: i ++ se usa principalmente porque, normalmente usamos el valor de inicio de i antes de incrementar para bucle. Pero dependiendo de la lógica de su progtwig, puede variar.

Supongo que ahora entiendes la diferencia en semántica (aunque sinceramente me pregunto por qué las personas preguntan ‘¿qué significa el operador X’ en desbordamiento de stack en lugar de leer, ya sabes, un libro o tutorial web o algo así?

Pero de todos modos, en cuanto a cuál usar, ignore las preguntas sobre el rendimiento, que son poco importantes incluso en C ++. Este es el principio que debe usar al decidir qué usar:

Di lo que quieres decir en código.

Si no necesita el valor antes de incremento en su extracto, no use esa forma del operador. Es un problema menor, pero a menos que esté trabajando con una guía de estilo que prohíbe una versión a favor de la otra en conjunto (también conocida como una guía de estilo de cabeza hueca), debe usar la forma que exprese exactamente lo que está tratando de hacer.

QED, use la versión de pre-incremento:

 for (int i = 0; i != X; ++i) ... 

La diferencia se puede entender por este simple código de C ++ a continuación:

 int i, j, k, l; i = 1; //initialize int i with 1 j = i+1; //add 1 with i and set that as the value of j. i is still 1 k = i++; //k gets the current value of i, after that i is incremented. So here i is 2, but k is 1 l = ++i; // i is incremented first and then returned. So the value of i is 3 and so does l. cout << i << ' ' << j << ' ' << k << ' '<< l << endl; return 0; 

La principal diferencia es

  • i ++ Post ( después del incremento ) y
  • ++ i Pre ( antes del incremento )

    • publicar si i =1 el bucle aumenta como 1,2,3,4,n
    • pre si i =1 el bucle aumenta como 2,3,4,5,n

En breve: ++ i e i ++ funcionan igual si no los está escribiendo en una función. Si usa algo como función (i ++) o función (++ i), puede ver la diferencia.

función (++ i) dice primer incremento i por 1, después de eso pon esto en la función con nuevo valor.

función (i ++) dice poner primero i en la función después de ese incremento i por 1.

 int i=4; printf("%d\n",pow(++i,2));//it prints 25 and i is 5 now i=4; printf("%d",pow(i++,2));//it prints 16 i is 5 now 

Precremento significa incremento en la misma línea. Incremento posterior significa incremento después de que la línea se ejecuta.

 int j=0; System.out.println(j); //0 System.out.println(j++); //0. post-increment. It means after this line executes j increments. int k=0; System.out.println(k); //0 System.out.println(++k); //1. pre increment. It means it increments first and then the line executes 

Cuando se trata de operadores OR, Y, se vuelve más interesante.

 int m=0; if((m == 0 || m++ == 0) && (m++ == 1)) { //false /* in OR condition if first line is already true then compiler doesn't check the rest. It is technique of compiler optimization */ System.out.println("post-increment "+m); } int n=0; if((n == 0 || n++ == 0) && (++n == 1)) { //true System.out.println("pre-increment "+n); //1 } 

En Array

  System.out.println("In Array"); int[] a = { 55, 11, 15, 20, 25 } ; int ii, jj, kk = 1, mm; ii = ++a[1]; // ii = 12. a[1] = a[1] + 1 System.out.println(a[1]); //12 jj = a[1]++; //12 System.out.println(a[1]); //a[1] = 13 mm = a[1];//13 System.out.printf ( "\n%d %d %d\n", ii, jj, mm ) ; //12, 12, 13 for (int val: a) { System.out.print(" " +val); //55, 13, 15, 20, 25 } 

En C ++ post / pre-incremento de variable de puntero

 #include  using namespace std; int main() { int x=10; int* p = &x; std::cout<<"address = "< 

El siguiente fragmento de código C ilustra la diferencia entre los operadores pre y post de incremento y decremento:

int i; int j;

// Incrementar operadores

i = 1;

j = ++ i; // ahora es 2, j también es 2

j = i ++; // ahora es 3, j es 2

i ++ y ++ i

Este pequeño código puede ayudar a visualizar la diferencia desde un ángulo diferente al de las respuestas ya publicadas:

 int i = 10, j = 10; printf ("i is %i \n", i); printf ("i++ is %i \n", i++); printf ("i is %i \n\n", i); printf ("j is %i \n", j); printf ("++j is %i \n", ++j); printf ("j is %i \n", j); 

El resultado es:

 //Remember that the values are i = 10, and j = 10 i is 10 i++ is 10 //Assigns (print out), then increments i is 11 j is 10 ++j is 11 //Increments, then assigns (print out) j is 11 

Preste atención a las situaciones antes y después.

en bucle

En cuanto a cuál de ellos debería usarse en un bloque de incremento de un ciclo for, creo que lo mejor que podemos hacer para tomar una decisión es usar un buen ejemplo:

 int i, j; For (i = 0; i <= 3; i++) printf (" > iteration #%i", i); printf ("\n"); for (j = 0; j <= 3; ++j) printf (" > iteration #%i", j); 

El resultado es:

 > iteration #0 > iteration #1 > iteration #2 > iteration #3 > iteration #0 > iteration #1 > iteration #2 > iteration #3 

No sé ustedes, pero no veo ninguna diferencia en su uso, al menos en un bucle for.

Puedes pensar en la conversión interna de eso como una statement múltiple ;

 // case 1 : i++; /* you can think as, * i; * i= i+1; */ // case 2 ++i; /* you can think as, * i = i+i; * i; */ 

a = i ++ significa que contiene un valor actual de i a = ++ i significa que contiene un valor incrementado i

Aquí está el ejemplo para entender la diferencia

 int i=10; printf("%d %d",i++,++i); 

salida: 10 12/11 11 (dependiendo del orden de evaluación de argumentos para la función printf , que varía entre comstackdores y architectures)

Explicación: i++ -> i se imprime, y luego se incrementa. (Imprime 10, pero i convertiré en 11) ++i -> valoro incrementos e imprimo el valor. (Imprime 12 y el valor de i también 12)