for-loop and++i in - What is the difference between ++i and i++?

i++ is known as Post Increment whereas ++i is called Pre Increment.

`i++`

`i++` is post increment because it increments `i`'s value by 1 after the operation is over.

Lets see the following example:

``````int i = 1, j;
j = i++;
``````

Here value of `j = 1` but `i = 2`. Here value of `i` will be assigned to `j` first then `i` will be incremented.

`++i`

`++i` is pre increment because it increments `i`'s value by 1 before the operation. It means `j = i;` will execute after `i++`.

Lets see the following example:

``````int i = 1, j;
j = ++i;
``````

Here value of `j = 2` but `i = 2`. Here value of `i` will be assigned to `j` after the `i` incremention of `i`. Similarly `++i` will be executed before `j=i;`.

For your question which should be used in the incrementation block of a for loop? the answer is, you can use any one.. doesn't matter. It will execute your for loop same no. of times.

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

And

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

Both the loops will produce same output. ie `0 1 2 3 4`.

It only matters where you are using it.

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

In this case output will be `1 2 3 4 5`.

with example c#

In C, what is the difference between using `++i` and `i++`, and which should be used in the incrementation block of a `for` loop?

`++i` increments the value, then returns it.

`i++` returns the value, and then increments it.

It's a subtle difference.

For a for loop, use `++i`, as it's slightly faster. `i++` will create an extra copy that just gets thrown away.

The reason `++i` can be slightly faster than `i++` is that `i++` can require a local copy of the value of i before it gets incremented, while `++i` never does. In some cases, some compilers will optimize it away if possible... but it's not always possible, and not all compilers do this.

I try not to rely too much on compilers optimizations, so I'd follow Ryan Fox's advice: when I can use both, I use `++i`.

They both increment the number. ++i is equivalent to i = i + 1.

i++ and ++i are very similar but not exactly the same. Both increment the number, but ++i increments the number before the current expression is evaluted, whereas i++ increments the number after the expression is evaluated.

Example :

``````int i = 1;
int x = i++; //x is 1, i is 2
int y = ++i; //y is 3, i is 3
``````

++i (Prefix operation): Increments and then assigns the value
(eg) : int i = 5 , int b = ++i
In this case, 6 is assigned to b first and then increments to 7 and so on.

i++ (Postfix operation): Assigns and then increments the value
(eg) : int i = 5 , int b = i++
In this case, 5 is assigned to b first and then increments to 6 and so on.

Incase of for loop : i++ is mostly used because, normally we use the starting value of i before incrementing in for loop.But depending on your program logic it may vary.

The difference can be understood by this simple C++ code below:

``````int i, j, k, l;
i = 1; //initialize int i with 1
j = i+1; //add 1 with i and set that as the value of j. i is still 1
k = i++; //k gets the current value of i, after that i is incremented. So here i is 2, but k is 1
l = ++i; // i is incremented first and then returned. So the value of i is 3 and so does l.
cout << i << ' ' << j << ' ' << k << ' '<< l << endl;
return 0;
``````

Shortly : ++i and i++ works same if you are not writing them in a function. If you use something like function(i++) or function(++i) you can see the difference.

function(++i) says first increment i by 1, after that put this i into the function with new value.

function(i++) says put first i into the function after that increment i by 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
``````

The following C code fragment illustrates the difference between the pre and post increment and decrement operators:

int i; int j;

// Increment operators

i = 1;

j = ++i; // i is now 2, j is also 2

j = i++; // i is now 3, j is 2

You can think of internal conversion of that as a multiple statements;

``````// case 1 :

i++;

/* you can think as,
* i;
* i= i+1;
*/

// case 2

++i;

/* you can think as,
* i = i+i;
* i;
*/
``````

Here is the example to understand the difference

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

output: `10 12/11 11` (depending on the order of evaluation of arguments to the `printf` function, which varies across compilers and architectures)

Explanation: `i++`->`i` is printed, and then increments. (Prints 10, but `i` will become 11) `++i`->`i` value increments and prints the value. (Prints 12, and the value of `i` also 12)