Difference between ++i and i++ [duplicate]

Answer 1

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 2

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

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 4

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.