Stack vs Heap C++

Question

I just had a quick question about how stack variables versus heap variables work. As I understand it, stack variables are variables that after functions return will be deleted, and heap variables are persistent. But what I'm really confused about is how to allocate heap variables inside functions:

int MyObject::addObject(const char* a){
    MyObject newObject(a);
    return 0;
}

Say that I have a constructor for MyObject that is newObject(const char * a). Then in this function when it is called, after the return does the newly constructed newObject get deleted? If yes, how can you allocate to the heap within a function then? If not, how do you cleanup your memory later?

Furthermore, what exactly is the role of a destructor and when is it called?

Answer 1

A constructor for the class MyObject is MyObject(), not newObject(). In your example, newObject is the name of your variable, not the constructor.

To allocate on the heap inside a function, you need to call the new operator:

int MyObject::addObject(const char* a){
    MyObject* newObject = new MyObject(a);
    //newObject is allocated on the heap

    //... Some more code...

    delete newObject;
    //you have to explicitly delete heap-allocated variables
    //if not, you get memory leaks
    return 0;
}

Your code:

MyObject newObject(a);

creates an automatic storage (stack) MyObject called newObject that lives until the scope it was declared in ends - i.e. closing }.

Furthermore, what exactly is the role of a destructor and when is it called?

To clean up memory the class allocated with new or new[] (or malloc) and it owns. It is called either when the object goes out of scope for automatic objects, or when you explicitly call delete for dynamic objects.

Answer 2

int addObject(const char* a){
    MyObject newObject(a);
    return 0;
}

This code allocates newObject on the stack. It is constructed (MyObject constructor is called on a chunk of stack memory) when entering the function. It's destructed (MyObject destructor called on that instance) when the function returns just before the chunk of memory is popped from the stack.

MyObject *foo =  new MyObject(a);

This code allocates an object on the heap. The constructor is called by the new operator after it's allocated some heap memory. The memory isn't freed and the destructor isn't called until you explicitly say you're done with it with the delete keyword.

delete foo;

This can be anywhere you want in your program.

Answer 3

Stack memory is what you said, but to be more specific, it's memory local to the current scope. Note that depending on what scope you're talking about, this memory could be global or it could be local to a function or class. These are cleaned up once they've gone out of scope.

Heap memory in allocated via the new operator. These will persist in memory even after all pointers pointing to the memory have gone out of scope. You must explicitly release this memory yourself in C++ via delete. Failing to do so will result in a memory leak unless smart pointers are used.

Another thing to note, take the following sample code:

void foo()
{
   int *bar = new int; //creates a pointer to an int on the stack, but initializes an int on the heap
   *bar = 3; //sets the int being pointed to to 3
   delete bar; //deletes the int
   bar = 0; //removes the now invalid reference
}

the pointer itself, bar, is created on the stack. However, the data pointed to by bar. *bar -- yes, the asterisk does make a difference here. It gets you the data pointed to by the pointer -- is on the heap. When foo returns, bar will go out of scope. Had I not called delete, I would have lost access to *bar and would have gotten a memory leak.

For the second question, the role of the dtor is to clean up the object you've constructed. One is provided by default for you, but there are times when you need to write your own. For example, if your class has raw pointers in it, you need to explicitly release them with delete in the dtor. It's called when the object goes out of scope for stack memory and when delete is called for heap memory.

Answer 4

• The stack is a an area that the is used in function and method calls. It is basically utilized to store parameters and function local data (among other things involved in the process of calling a function). The stack is a LIFO kind of data structure, meaning that the last thing you put in is the first you get from it.

• The heap on the other hand is a free store, by that I mean you can get any values from the heap no matter the order it was put in there - this distinction is important.

• In C++ , every time you call new the object is created on the Heap and a pointer to that object is returned to you, you can then use that pointer to access your object. That applies to both complex objects such as objects from classes you or someone else has created, and built in types, such as int, char, double etc... There is nothing magical with using new, at it's core it simply calls malloc, or some flavor of it depending on the platform, and then calls the constructor for the object. You have to remember to call delete (or delete []p_array_of_object_pointers) for every object created with new.

• The destructor is nothing more than a function that the language calls on the object when you do a delete my_object_pointer in your code. The destructor gives you a chance of doing some clean up in your code. In languages such as C++, where you have to manage your own resources, you would usually use it to call delete or free on other objects you have allocated on the heap, or closing file handles you've created with fopen or such...

• Both of this keywords work inside or outside a functions and methods, it does not matter where you call them from, they will always work with the heap. Anything you create without the use of new will end up in some other place, either the static area of the executable or the stack, depending on how and where it is being created.

• Every time you create an object inside a method or function with the following syntax MyClassType myObject(contructor, arguments); and without the use of new, you are creating it on the stack (unless you declare it as static, which is when it ends up in that static area I mentioned above).

Hope this helps.

Answer 5

heap allocations are done with the new keyword

C++ has no garbage collection, heap allocations are never automatically freed

you can free them with the delete keyword

you need to keep a pointer for that, for example by returning it from the function, or by assigning it to a global variable

destructors are called on delete and are used to free resources, for example network sockets

so the code would be, for example return new MyObject("foo");

Answer 6

How to allocate to heap: use new keyword

How to deallocate from heap: use delete keyword.

To avoid program crashing and memory leaks, each new must have its delete counterpart for the specified object and type.

Destructor is called when object gets deleted regardless of where it was stored(heap, stack, ...)

And here's more specific info about memory: What and where are the stack and heap?

Answer 7

Use dynamically allocated instances of objects when:

1) The actual type of object is not known at compile time 2) When the number of objects you want to create, is not known at compile time 3) When the (compiler generated) lifetime management of your objects does not meet your needs.

Every object created with new operator, should be freed with delete operator at some time. If you don't, you will have memory leaks, and if you depend on the side effects of the objects destructor, you won't get those side effects and your program may not do what it is desired to do.

When an object is created as a stack variable, the compiler will insert code to call the objects destructor when the object goes out of scope. How does the compiler know what destructor to call? The type of object is known at compile time, so there is only one posibility, only one destructor to call.

If you use 'delete' to destroy an object, the compiler may not be able to tell which destructor to use. The object may be of type 'basic', then the destructor 'basic::~basic()' will be called.

    class basic;
    class derived : public basic
    {
           ....
           ~derived();
    }

    basic *l = new derived();
    ...
    delete l;

The compiler does not know the actual type of the object is not 'basic' but 'derived'. If however, you declare the destructor of 'basic' to be virtual, the compiler will insert code that consults the objects virtual method table, and the call is redirected to the right destructor (in this case the destructor that destructs on object of type 'derived').

If you are worried about this problem, and if you can, make the destructor 'virtual'.

Answer 8

You allocate memory in stack in your example. It's automatic variable and it would be deleted then return happened. If you use new keyword you must provide correct deallocation

MyObject* newObject = new MyObject(a);