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 function, ex:

int addTwo(int num)
{
    int temp = 2;
    num += temp;
    return num;
}

So in this example, would temp be removed from memory after the function ends? If not, how is this done. In C# a variable gets removed once its scope is used up. Are there also any other cases I should know about?

Thanks

Answer 1

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 2

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 3

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 4

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

C++ scope rules are similar to C#.

Answer 5

Its not removed from memory once the function exits.

It remains in memory, in addTwo's stack frame, until some other process (or the same) re uses that portion of memory.

Until that point, accessing temp is undefined behaviour.

Answer 6

In this case both num and temp are local to this function. When the function is called the number passed into num is copied from the caller to a variable on the stack. Temp is then created on the stack. When you return the value of num is copied back to the caller, and the temp and num variables used in the function are dropped.

Answer 7

This code is plain C. Therefore there is no C++ memory management going on here. This would only be the case if "new" would be used to create temp.

Answer 8

In C,C++ local variables have automatic storage class and are stored in Stack.

When function returns then stack gets unwound and locals are no more accessible, but they still persist in memory and that's the reason when u define a variable in function it may contain garbage value.

It is just stack pointer manipulation in stack and on memory for local is removed actually.

Answer 9

In C++ there is a very simple rule of thumb:

All memory is automatically freed when it runs out of scope unless it has been allocated manually.

Manual allocations:

• Any object allocated by new() MUST be de-allocated by a matching delete().
• Any memory allocated by malloc() MUST be de-allocated by a matching free().

A very useful design pattern in C++ is called RAII (Resource Acquisition Is Initialization) which binds dynamic allocations to a scoped object that frees the allocation in its destructor.

In RAII code you do not have to worry anymore about calling delete() or free() because they are automatically called whenever the "anchor object" runs out of scope.

Answer 10

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

http://stackoverflow.com/questions/1612982/how-does-automatic-memory-allocation-actually-work-in-c/1613391#1613391

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 11

In C++, any object that you declare in any scope will get deleted when the scoped exits. In the example below, the default constructor is called when you declare the object and the destructor is called on exit, ie, ~MyClass.

void foo() {
  MyClass object;
  object.makeWonders();
}

If you declare a pointer in a function, then the pointer itself (the 4 bytes for 32 bit systems) gets reclaimed when the scoped exits, but the memory you might have allocated using operator new or malloc will linger - this is often known as memory leak.

void foo() {
  MyClass* object = new MyClass;
  object->makeWonders();
  // leaking sizeof(MyClass) bytes.
}

If you really must allocate an object via new that needs to be deleted when it exits the scope then you should use boost::scoped_ptr like so:

void foo() {
  boost::scoped_ptr<MyClass> object(new MyClass);
  object->makeWonders();
  // memory allocated by new gets automatically deleted here.
}

Answer 12

Normally memory managment is used in the context of dynamic memory that is created by

new
mallo

In the normal code C++ behaves like every other language. If you create a variable or return it, it is copied and accessible on the target side.

int a = addTwo(3);

gets a copy of your returned value. If the returned value is a class copy operator called. So as long as you do not work with new and malloc you do not have to care about memory managment that much.

One additional remark which is important

void func(std::string abc)
{
  // method gets a copy of abc
}

void func(std::string& abc)
{
  // method gets the original string object which can be modified without having to return it
}

void func(const std::string& abc)
{
  // method gets the original string object abc but is not able to modify it    
}

The difference of the three lines is very important because your program may spare a lot of time creating copies of input parameters that you normally didn't want to create.

e.g.

bool CmpString(std::string a, std::string b)
{
  return a.compare(b);
}

is really expensive because the atrings a and b are always copied. Use bool CmpString(const std::string& a, const std::string& b) instead.

This is important because no refcounted objects are used by default.

Answer 13

I didn't see any mention of the case for static variables declared in a function, so here are my rules (interpretation of the C++ specification).

This question is more about the duration or lifetime of a variable, rather than where the variable is stored.

Variables declared as non-static within a function exist from the "beginning" of the function until the execution leaves the function. The "beginning" is defined as the first executable instruction. Technically, they variables exist until execution leaves the scope that they were declared.

Variables declared as static (prefixed with the keyword `static`), are created before main() and exist until the program terminates.

Variables that are dynamically allocated (via new or malloc) exist until they are specifically deallocated, the program ends or all pointers to them are lost or changed. The latter rule results in "memory leaks"; the variable still exists, but can't be accessed.

Reclaiming memory for variables is up to the implementation (or compiler) and not defined in the specification.