When are variables removed from memory in C++?

Question

I\'ve been using C++ for a bit now. I\'m just never sure how the memory management works, so here it goes:

I\'m first of all unsure how memory is unallocated in a fu

Answer 1

Here, temp is allocated on the stack, and the memory that it uses is automatically freed when the function exits. However, you could allocate it on the heap like this:

int *temp = new int(2);

To free it, you have to do

delete temp;

If you allocate your variable on the stack, this is what typically happens:

When you call your function, it will increment this thing called the 'stack pointer' -- a number saying which addresses in memory are to be 'protected' for use by its local variables. When the function returns, it will decrement the stack pointer to its original value. Nothing is actually done to the variables you've allocated in that function, except that the memory they reside in is no longer 'protected' -- anything else can (and eventually will) overwrite them. So you're not supposed to access them any longer.

If you need the memory allocated to persist after you've exited the function, then use the heap.

Answer 2

The local variable temp is "pushed" on a stack at the beginning of the function and "popped" of the stack when the function exits.

Here's a disassembly from a non optimized version:

int addTwo(int num)
{
00411380  push        ebp  
00411381  mov         ebp,esp             //Store current stack pointer
00411383  sub         esp,0CCh            //Reserve space on stack for locals etc
00411389  push        ebx  
0041138A  push        esi  
0041138B  push        edi  
0041138C  lea         edi,[ebp-0CCh] 
00411392  mov         ecx,33h 
00411397  mov         eax,0CCCCCCCCh 
0041139C  rep stos    dword ptr es:[edi] 
    int temp = 2;
0041139E  mov         dword ptr [temp],2 
    num += temp;
004113A5  mov         eax,dword ptr [num] 
004113A8  add         eax,dword ptr [temp] 
004113AB  mov         dword ptr [num],eax 
    return num;
004113AE  mov         eax,dword ptr [num] 
}
004113B1  pop         edi  
004113B2  pop         esi  
004113B3  pop         ebx  
004113B4  mov         esp,ebp                 //Restore stack pointer
004113B6  pop         ebp  
004113B7  ret        

The terms "pushed" and "popped" are merely meant as an analogy. As you can see from the assembly output the compiler reserves all memory for local variables etc in one go by subtracting a suitable value from the stack pointer.

Answer 3

Variable temp is stack allocated. That means it's deallocated when the function returns.

See e.g.:

• http://msdn.microsoft.com/en-us/library/ew5tede7%28VS.80%29.aspx
• http://en.wikipedia.org/wiki/Stack_%28data_structure%29

Answer 4

Please see my answer to this question. It may clear up a lot of things for oyu.

How does automatic memory allocation actually work in C++?

I'm not just posting a link for giggles. My answer there is an in-depth look (at a very introductory level) how memory management works.

Answer 5

temp is allocated on the stack. So when the function returns, it is gone.

C++ scope rules are similar to C#.