operadores - postincremento




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

La principal diferencia es

  • i ++ Post ( Después de Incremento ) y
  • ++ i Pre ( antes del incremento )

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

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


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 

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

en bucle

En cuanto a cuál de ellos debe usarse en un bloque de incremento de un bucle 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é sobre usted, pero no veo ninguna diferencia en su uso, al menos en un bucle for.


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 ++ i incrementa el número antes de que se evalúe la expresión actual, mientras que i ++ incrementa el número después de que se evalúa 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

Aquí está el ejemplo para entender la diferencia.

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

salida: 10 12/11 11 (según el orden de evaluación de los argumentos de la función printf , que varía entre compiladores y arquitecturas)

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


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

int i; int j;

// Incrementar operadores

i = 1;

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

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


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

La función (++ i) dice el primer incremento i en 1, luego de eso, coloque este i en la función con nuevo valor.

la función (i ++) dice poner primero i en la función después de ese incremento i en 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

La razón por la que ++i puedo 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 compiladores lo optimizarán si es posible ... pero no siempre es posible, y no todos los compiladores hacen esto.

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


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


Supongo que ahora entiendes la diferencia en la semántica (aunque, honestamente, me pregunto por qué la gente pregunta "¿qué significa el operador X?" En el desbordamiento de pila 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 cuestiones de rendimiento, que probablemente no sean importantes incluso en C ++. Este es el principio que debe utilizar al decidir cuál usar:

Di lo que quieres decir en el código.

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

QED, usa la versión pre-incremento:

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

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


++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 tirará.


++ 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 se incrementa a 6 y así sucesivamente.

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


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

i++

i++ es un incremento posterior porque incrementa el valor de i en 1 una vez que finaliza la operación.

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 se incrementará.

++i

++i es pre incremento porque incrementa 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 de la incrementación de i de i . De forma similar, ++i se ejecutará antes de j=i; .

Para su pregunta, ¿ qué debe usarse en el bloque de incremento de un bucle for? La respuesta es, puedes usar cualquiera ... no importa. Se ejecutará su bucle for no mismo. 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 donde lo estés usando.

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

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


  • ++i Incrementaré 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 i antes de ser incrementado.

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

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

En cualquier caso, siga la pauta "prefiero ++i en lugar de i++ " y no se equivocará.

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

La pregunta de eficiencia es interesante ... aquí está mi intento de respuesta: ¿hay una diferencia de rendimiento entre i ++ y ++ i en C?

Como lo señala On Freund , es diferente para un objeto C ++, ya que operator++() es una función y el compilador no puede saber cómo optimizar la creación de un objeto temporal para mantener el valor intermedio.







pre-increment