What is the difference between prefix and postfix operators?

Question

The following code prints a value of 9. Why? Here return(i++) will return a value of 11 and due to --i the value should be 10 itself, can anyone explain how this works?

#include<stdio.h>
main()
{
    int i= fun(10);
    printf("%d\n",--i);
}

int fun (int i)
{
    return(i++);
}

Answer 1

There is a big difference between postfix and prefix versions of ++.

In the prefix version (i.e., ++i), the value of i is incremented, and the value of the expression is the new value of i.

In the postfix version (i.e., i++), the value of i is incremented, but the value of the expression is the original value of i.

Let's analyze the following code line by line:

int i = 10;   // (1)
int j = ++i;  // (2)
int k = i++;  // (3)

1. i is set to 10 (easy).
2. Two things on this line:
   • i is incremented to 11.
   • The new value of i is copied into j. So j now equals 11.
3. Two things on this line as well:
   • i is incremented to 12.
   • The original value of i (which is 11) is copied into k. So k now equals 11.

So after running the code, i will be 12 but both j and k will be 11.

The same stuff holds for postfix and prefix versions of --.

Answer 2

Prefix:

int a=0;

int b=++a;          // b=1,a=1 

before assignment the value of will be incremented.

Postfix:

int a=0;
int b=a++;  // a=1,b=0 

first assign the value of 'a' to 'b' then increment the value of 'a'

Answer 3

The function returns before i is incremented because you are using a post-fix operator (++). At any rate, the increment of i is not global - only to respective function. If you had used a pre-fix operator, it would be 11 and then decremented to 10.

So you then return i as 10 and decrement it in the printf function, which shows 9 not 10 as you think.

Answer 4

In fact return (i++) will only return 10.

The ++ and -- operators can be placed before or after the variable, with different effects. If they are before, then they will be processed and returned and essentially treated just like (i-1) or (i+1), but if you place the ++ or -- after the i, then the return is essentailly

return i;
i + 1;

So it will return 10 and never increment it.

Answer 5

There are two examples illustrates difference

int a , b , c = 0 ; 
a = ++c ; 
b = c++ ;
printf (" %d %d %d " , a , b , c++);

• Here c has value 0 c increment by 1 then assign value 1 to a so value of a = 1 and value of c = 1

• next statement assiagn value of c = 1 to b then increment c by 1 so value of b = 1 and value of c = 2

• in printf statement we have c++ this mean that orginal value of c which is 2 will printed then increment c by 1 so printf statement will print 1 1 2 and value of c now is 3

you can use http://pythontutor.com/c.html

int a , b , c = 0 ; 
a = ++c ; 
b = c++ ;
printf (" %d %d %d " , a , b , ++c);

• Here in printf statement ++c will increment value of c by 1 first then assign new value 3 to c so printf statement will print 1 1 3

Answer 6

The postfix increment ++ does not increase the value of its operand until after it has been evaluated. The value of i++ is i.

The prefix decrement increases the value of its operand before it has been evaluated. The value of --i is i - 1.

Prefix increment/decrement change the value before the expression is evaluated. Postfix increment/decrement change the value after.

So, in your case, fun(10) returns 10, and printing --i prints i - 1, which is 9.

Answer 7

Explanation:

Step 1: int fun(int); Here we declare the prototype of the function fun().

Step 2: int i = fun(10); The variable i is declared as an integer type and the result of the fun(10) will be stored in the variable i.

Step 3: int fun(int i){ return (i++); } Inside the fun() we are returning a value return(i++). It returns 10. because i++ is the post-increement operator.

Step 4: Then the control back to the main function and the value 10 is assigned to variable i.

Step 5: printf("%d\n", --i); Here --i denoted pre-increement. Hence it prints the value 9.

Answer 8

Let's keep this as simple as possible.

let i = 1
console.log('A', i)    // 1
console.log('B', ++i)  // 2
console.log('C', i++)  // 2
console.log('D', i)    // 3

A) Prints the value of I.

B) First i is incremented then the console.log is run with i as it's the new value.

C) Console.log is run with i at its current value, then i will get incremented.

D) Prints the value of i.

In short, if you use the pre-shorthand i.e(++i) I will get updated before the line is executed. If you use the post-shorthand i.e(i++) the current line will run as if I had not been updated yet then i get increased so the next time your interpreter comes across i it will have been increased.

Answer 9

i++ is post increment. The increment takes place after the value is returned.

Answer 10

First, note that the function parameter named i and the variable named i in main() are two different variables. I think that doesn't matter that much to the present discussion, but it's important to know.

Second, you use the postincrement operator in fun(). That means the result of the expression is the value before i is incremented; the final value 11 of i is simply discarded, and the function returns 10. The variable i back in main, being a different variable, is assigned the value 10, which you then decrement to get 9.

Answer 11

Actually what happens is when you use postfix i.e. i++, the initial value of i is used for returning rather than the incremented one. After this the value of i is increased by 1. And this happens with any statement that uses i++, i.e. first initial value of i is used in the expression and then it is incremented.

And the exact opposite happens in prefix. If you would have returned ++i, then the incremented value i.e. 11 is returned, which is because adding 1 is performed first and then it is returned.

Answer 12

It has to do with the way the post-increment operator works. It returns the value of i and then increments the value.

Answer 13

fun(10) returns 10. If you want it to return 11 then you need to use ++i as opposed to i++.

int fun(int i)
{
    return ++i;
}