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?

Hi 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 there is sth that I am not able to see

Thanks in advance

Answer 1

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

Answer 2

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 3

++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 4

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 5

++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 6

++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 7

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 8

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.

Answer 9

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 10

Hi

I don't know whether you understand pre and post increment properly. But visualize it this way

pre increment

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

first ++i increments value of i to 11.

second ++i increments it to 12.

than those values are added.

i.e.

i = i + 1;
i = i + 1;
k = i + i;(at this state value of i is equal to 12 therefore you get k = 24)

---

post increment

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

think of i++ will increment value of i after current statement.

i.e. we have one pre increment and one post increment in this example.

so, it will execute in sequence like this

i = i + 1; ( one pre increment statement)
k = i + 1; ( Current statement . At this stage value of i is 11. Therefore you get k=22)
i = i + 1; ( Post increment statement)

In short value of variable is incremented before or after the execution of statement in which they are used in manner ++i or i++ respectively.

Answer 11

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 12

Thanks Guy's I understand a lot from this example.