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++);
}
This question is related to
c
postfix-operator
prefix-operator
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)
i
is set to 10
(easy).i
is incremented to 11
.i
is copied into j
. So j
now equals 11
.i
is incremented to 12
.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 --
.
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.
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.
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.
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;
}
i++ is post increment. The increment takes place after the value is returned.
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.
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'
It has to do with the way the post-increment operator works. It returns the value of i and then increments the value.
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
.
There are two examples illustrates difference
int a , b , c = 0 ;
a = ++c ;
b = c++ ;
printf (" %d %d %d " , a , b , c++);
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);
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
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 new value. C) Console.log is run with i at its current value, then i will get incemented. 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 gets increased so ther next time your interpreter comes accross i it will have been increrased.
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.
Source: Stackoverflow.com