confusion regarding return statement [duplicate] - c

Question

This question already has an answer here:
Regarding post increment
(1 answer)
Closed 9 years ago.
int demo()
{
static int i = 1;
return i++;
}
int main()
{
printf("%d %d %d\n", demo(), demo(), demo());
return 0;
}
output:-
3 2 1
During the first demo call, 1 is returned.
I have heard that when return statement is executed, then control passes to the calling function without any further execution of code in called function.
So my question is that in my code when 1 is returned in first call, Why its value is incremented?
In other words I want to know that after returning 1 , why ++ is executed?

Answer 1

int demo()
{
static int i = 1;
return i++;
}
int main()
{
printf("%d %d %d\n", demo1(), demo2(), demo3());
return 0;
}
The order of execution of demo_i() is language dependent .
Now, comes use of static keyword .
Static variables persist on the stack through the entire duration of the program , even after function ends and returns the value .
Due to this , 1st time : i=1
return 1 , increment to 2 .
2nd time : i=2
return 2 , increment to 3 .
3rd time : i=3
return 3 , increment to 4 .
Hope this helps !

Answer 2

Three points to keep in mind here:
static variables into functions persist through the entire duration of the program as soon as they're created for the first time
That variable returned also has the postfix ++ operator which means: "use the value (i.e. return it) and increment it AFTERWARDS": the incremented value is not returned.
That's why that variable has "memory" of what happened and gets incremented.
-> Why you're seeing "3 2 1" instead of "1 2 3"?
The order in which the parameters are evaluated is not known 'a priori' and it's up to the compiler decide it, see https://stackoverflow.com/a/12960263/1938163
If you really want to know how is it possible that the value gets first returned and then incremented, take a look at the generated asm code:
demo(): # #demo()
movl demo()::i, %eax # move i and put it into eax
movl %eax, %ecx # Move eax into ecx -> eax will be used/returned!
addl $1, %ecx # Increment ecx
movl %ecx, demo()::i # save ecx into i -> this is for the next round!
ret # returns!
main: # #main
pushq %rbp
movq %rsp, %rbp
subq $16, %rsp
movl $0, -4(%rbp)
callq demo() # Call demo()
movl %eax, -8(%rbp) # save eax in rbp-8 (contains 1, demo::i is 2 for the next round)
callq demo() # Call demo()
movl %eax, -12(%rbp) # save eax in rbp-12 (contains 2, demo::i is 3 for the next round)
callq demo() # Call demo()
leaq .L.str, %rdi # load str address
movl -8(%rbp), %esi # esi points to 1
movl -12(%rbp), %edx # edx points to 2
movl %eax, %ecx # move eax (3) into ecx (demo::i is 4 but doesn't get used)
movb $0, %al # needed by the ABI to call printf
callq printf # call printf() and display 3 2 1
movl $0, %ecx
movl %eax, -16(%rbp)
movl %ecx, %eax
addq $16, %rsp
popq %rbp
ret
demo()::i:
.L.str:
.asciz "%d %d %d\n"
The 64-bit ABI uses registers (RDI, RSI, RDX, RCX, R8 and R9) instead of the stack for argument passing.

Answer 3

[...] I want to know that after returning 1, why ++ is executed?
The postfix operator is defined by the C Standard to work like this:
6.5.2.4 Postfix increment and decrement operators
[...]
2 The result of the postfix ++ operator is the value of the operand. After the result is
obtained, the value of the operand is incremented. (That is, the value 1 of the appropriate
type is added to it.)
So before the return is executed i is increment, but as the result of the postfix operation is the "original" value, return returns this "original" value.

Answer 4

Your function returns old value of i and increments it . Since you used static keyword the value of i is stored and available for next call (it is not vanished after the call).
I have heard that when return statement is executed, then control passes to the calling function without any further execution of code in called function.
You heard right. But it doesn't mean that the statement which is returned by return statement does not executed. See an example:
return a + b;
Now this statement executed then a+b get evaluated first and then its value is returned to the caller. In a similar way when
return i++;
get executed then i++ is executed. It returns the previous value of i and increment it by 1.