diferencia entre ++ i y i ++

Question

posibles duplicados:
What is more efficient i++ or ++i?
How do we explain the result of the expression (++x)+(++x)+(++x)?
Difference between i++ and ++i in a loop?

Hola Estoy tratando estos dos programas

void fun(){ 
    int k=0; 
    int i=10; 
    k = (i++)+(++i); 
    cout<<k<<endl; 

} 
Output = 22 as i++ will give 10 and ++i will evaluate into 12 

pero

void fun(){ 
    int k=0; 
    int i=10; 
    k = (++i)+(++i); 
    cout<<k<<endl; 

} 
Output = 24 

Debe ser 23 supongo que o hay algo que no soy capaz de ver

Gracias de antemano

Answer 1

Nota: está invocando un comportamiento indefinido (modificación de una variable de dos veces entre los puntos de secuencia)

Answer 2

Supongo que ambos operadores de preincremento se están ejecutando antes de que se calcule la declaración de adición. por lo tanto, 24.

Todo depende de cómo ve el compilador lo que está haciendo, pero supongo que eso es lo que está viendo.

Answer 3

++ sucede antes de calcular la expresión completa e i ++ sucede después. En el primer ejemplo ocurre uno de los incrementos antes de calcular el valor, entonces "i" se convierte en 21 y obtienes 21 + 21. En el último ejemplo ambos suceden antes, entonces "i" se convierte en 22 y obtienes 22 + 22.

Answer 4

i ++ es post-incremento, ++ i es pre-incremento. i ++ aumentará i después de que se complete la declaración.

Para ilustrar en sus ejemplos:

Ejemplo 1:

k = 0 
i = 10 

i += 1 
k = i + i // 11 + 11 
i += 1 

Ejemplo 2:

k = 0 
i = 10 

i += 1 
i += 1 
k = i + i // 12 + 12 

Answer 5

++ daré resultado i = i + 1. Si i = 10, entonces en k = (++ i) + (++ i); expresión (++ i) dará un valor incrementado, lo que significa que se producirá el primer incremento, pero en el caso de i ++, el incremento se verá afectado en i después de la expresión.

Así i = 10

k = (i ++) + (++ i);

10 11 12 

10 + 12=22 

k = (++ i) + (++ i);

11 11 12 

    11 + 12=23 

Answer 6

++i generalmente devuelve una referencia a la propia variable de modo que la segunda modificación también afecta a la memoria que contiene el resultado de la primera modificación. (Incremento posterior i++, por otro lado, tiene que devolver una copia del valor para que funcione correctamente.)

Una definición típica de ++i en C++ (utilizando la sobrecarga de operadores) sería

struct Foo{ 
    //... 
    Foo const & operator++(){ //this implements ++i 
    //do something to increment 
    return *this; 
    } 
    Foo operator++(int){ //this implements i++ 
    Foo old(*this); 
    //do something to increment 
    return old; 
    } 
}; 

Answer 7

Esto pareció muy interesante, por lo que tomó un vistazo en el desmontaje (MSVC++ 2008)

 k = (++i)+(++i); 
0122413C mov   eax,dword ptr [i] 
0122413F add   eax,1 
01224142 mov   dword ptr [i],eax 
01224145 mov   ecx,dword ptr [i] 
01224148 add   ecx,1 
0122414B mov   dword ptr [i],ecx 
0122414E mov   edx,dword ptr [i] 
01224151 add   edx,dword ptr [i] 
01224154 mov   dword ptr [k],edx 

Como puede ver, incrementa i dos veces y luego agrega i a sí mismo. Lo mismo sucede si hay varias instancias de (++i).

De todos modos, dado que el estándar no garantiza nada, la modificación de i más de una vez conducirá a un comportamiento indefinido.

Answer 8

Para determinar esto, se está llevando a cabo el siguiente paso.

1). Se determina todo ++i.

2). El valor de i se usa luego para cada término que es ++i y i++.

3). Se determina todo i++.

Primer caso:

 int k=0; 
    int i=10; 
    k = (i++)+(++i);

1) Hay uno de ++i así que al entonces final de este paso i = 11 (una vez).

2) Ahora que se convierta en k = (11)+(11);

3) Hay uno de i++ así que al entonces final de este paso i = 12 (una vez).

Segundo caso:

 int k=0; 
    int i=10; 
    k = (++i)+(++i);

1) Hay uno de ++i así que al entonces final de este paso i = 12 (dos veces).

2) Ahora que se convierta en k = (12)+(12);

3) Hay uno de i++ así que al entonces final de este paso i = 12 (tiempo cero).

creo un código de prueba:

#include <stdio.h> 
int main(void) { 
    int K=0; 
    int I=10; 
    K = (I++)+(++I); 
    printf("I: %d; K: %d\n", I, K); 

    K=0; 
    I=10; 
    K = (++I)+(++I); 
    printf("I: %d; K: %d\n", I, K); 
}

Cuando se ejecuta, el resultado es:

I: 12; K: 22 
I: 12; K: 24

Espero que esto ayude.

Answer 9

Según C++ 03 estándar 5/4 el comportamiento de los programas en cuestión no está definida:

Excepto donde se indique, el orden de evaluación de los operandos de los operadores y subexpresiones de indicación vidual individuales expresiones, y el orden en que se producen los efectos secundarios, no se especifica. 53) Entre el anterior y el siguiente punto de secuencia, un objeto escalar tendrá su valor almacenado modificado a lo sumo por la evaluación de una expresión. Además, se accederá al valor anterior solo para determinar el valor que se almacenará. Los requisitos de este párrafo se cumplirán para cada ordenamiento permitido de las subexpresiones de una expresión completa ; de lo contrario, el comportamiento no está definido.

Answer 10

Una variable nunca se debe aumentar más de una vez dentro de una sentencia, porque el comportamiento del compilador no está definido.

Para evitar los efectos secundarios, haga dos afirmaciones para sus ejemplos.

Ejemplo 1: k = i ++; k + = ++ i;

Ejemplo 2: k = ++ i; k + = ++ i;

Si lo hace, su código funcionará correctamente.