Difference between ++i and i++

Question

Possible Duplicates:
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?

I am trying these two programs:

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.

But

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

Output = 24

It should be 23 I guess, or is there something that I am not able to see?

Answer 1

Note: you are invoking undefined behavior (modifying a variable twice between sequence points)

Answer 2

According to C++03 Standard 5/4 the behavior of the programs in question is undefined:

Except where noted, the order of evaluation of operands of individual operators and subexpressions of indi- vidual expressions, and the order in which side effects take place, is unspecified. 53) Between the previous and next sequence point a scalar object shall have its stored value modified at most once by the evaluation of an expression. Furthermore, the prior value shall be accessed only to determine the value to be stored. The requirements of this paragraph shall be met for each allowable ordering of the subexpressions of a full expression; otherwise the behavior is undefined.

Answer 3

This seemed really interesting, so I took a peek at the disassembly (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 

As you can see, it increments i twice and then adds i to itself. The same thing happens if there are multiple instances of (++i).

Anyway, since the Standard doesn't guarantee anything, modifying i more than once will lead to undefined behaviour.

Answer 4

A variable never should be increased more than one time within one statement, because the behaviour of the compiler isn't defined.

To avoid side effects, make two statements for your examples.

Example 1: k = i++; k += ++i;

Example 2: k = ++i; k += ++i;

If you do so, your code will work correctly.

Answer 5

I'm guessing that both pre-increment operators are running before the addition statement gets calculated. hence 24.

All depends on how the compiler sees what you're doing, but I'm guessing that's what you're seeing.

Answer 6

i++ is post-increment, ++i is pre-increment. i++ will increment i after the statement is completed.

To illustrate in your examples:

Example 1:

k = 0
i = 10

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

Example 2:

k = 0
i = 10

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

Answer 7

++i will give result i=i+1. If i=10 then in k = (++i)+(++i); expression (++i) will give incremented value that means first increment will happen but in case of i++ the increment will be affected on i after the expression.

So i=10

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

 10    11   12

 10    +  12=22  

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

 11   11  12

  11   +  12=23

Answer 8

++i usually returns a reference to the variable itself so the second modification also affects the memory that holds the result from the first modification. (Post-increment i++, on the other hand, has to return a copy of the value in order to work properly.)

A typical definition of ++i in C++ (using operator overloading) would be

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 9

++i happens before calculating the whole expression and i++ happens after. In the first example one of increments happen before calculating the value, so "i" becomes 21 and you get 21 + 21. In the last example both happen before, so "i" becomes 22 and you get 22 + 22.

Answer 10

To determine this the following step is taking.

1). All of ++i is determined.

2). The value of i is then used to each term that is ++i and i++.

3). All of i++ is determined.

First case:

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

1) There is one of ++i so at then end of this step i = 11 (once).

2) Now it become k = (11)+(11);

3) There is one of i++ so at then end of this step i = 12 (once).

Second case:

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

1) There is one of ++i so at then end of this step i = 12 (twice).

2) Now it become k = (12)+(12);

3) There is one of i++ so at then end of this step i = 12 (zero time).

I create a test code:

#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);
}

When executed, the result is:

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

Hope this helps.