What happens to the variables inside?

Question

What happens to the variables inside that function ?

void function()
{
   int a = 5;
   a += a; //a contain 10
}

int main()
{
   function();
   return 0;
}

so what happened here after the function (function()) execution is done does this variable (a) is it still found in memory (uses memory) with its last value which is (10) or its destroyed completely and no longer in memory ?

`a` exists only inside the function. It comes into existence every time the function is called, and goes out of existence every time it exits. — StoryTeller - Unslander Monica, Nov 09 '16 at 19:14
could be a [duplicate](http://stackoverflow.com/questions/1880984/when-are-variables-removed-from-memory-in-c) question — Sam W, Nov 09 '16 at 19:16
If you had a really good compiler all that would happen is it returns 0. — NathanOliver, Nov 09 '16 at 19:16
@Nathan The whole program optimized to `int main() {}` most probably. — πάντα ῥεῖ, Nov 09 '16 at 19:27

tadman · Answer 1 · 2016-11-09T19:19:52.757

2

It's generally stored on the stack, that is it's automatically allocated, and the memory for those automatica allocations gets recycled for each function call. Your compiler might decide that this variable is actually useless and ignore it completely since it's never used and doesn't impact any other parts of your code, so what might happen is: Nothing.

In C and C++ it's important to remember there's a huge difference between local variables, which are considered to be automatically-allocated and only survive as long as the function is executing, and dynamically-allocated via pointers and new which survive until they're either removed with delete or the program terminates.

edited Nov 09 '16 at 19:19

answered Nov 09 '16 at 19:14

tadman

208,517
23
234
262

4

Please use automatic(stack) and dynamic(heap) when talking about storage duration. stack and heap are just common implementations. – NathanOliver Nov 09 '16 at 19:18
Welcome to Automatic Overflow, I guess! – tadman Nov 09 '16 at 19:19
@tadman, cute. But "automatic storage duration" will still be correct when co-routines are introduced into c++. "stack" will not necessarily be. – StoryTeller - Unslander Monica Nov 09 '16 at 19:24

score 2 · Accepted Answer · answered Nov 09 '16 at 19:16

It's not really specified. I'll describe the naive case first, and then explain why it may not really apply.

Naively, the memory a was stored in still exists, although the name a is no longer reachable outside function. The memory may or may not still contain 10 - the compiler is free to overwrite it or to not bother. Obviously it may also be reused as something else any time afterwards.

If a was really allocated in memory, that might be in a region known as the (call) stack, but this is just a popular calling convention and not required by the language.

Now, the compiler is also free to store a only in a register since it notices the address is never taken, in which case it was never in memory in the traditional sense.

The compiler is further free to notice that a is never observably used at all, and not bother emitting any of the code inside function.

score 0 · Answer 3 · answered Nov 09 '16 at 19:19

When function ends all its local variables essentially disappear (more precisely, they disappear when their block ends).

Talking about their "last value" remaining "in memory" is a rather pointless exercise since there's a possibility that their value has never been in memory in the first place. And even if it has, there's no guarantee that it is still there, or that that memory is still accessible in any sense.

What happens to the variables inside?

3 Answers3