Memory Management

• When you get done using heap memory, it needs to be cleaned up. This can done using a process known as ‘garbage collection’, or manually by the developer when creating the app
• Implementation of both the stack and heap is usually down to the runtime / OS.
• There are 2 memory constructs, stack and heap.

Stack:

• A stack is a structure that represents a sequence of objects or elements that are available in a linear data structure. What does that mean? It simply means you can add or remove elements in a linear order. This way, a portion of memory that keeps variables created can function temporarily.
• Stored in computer RAM just like the heap.
• Variables created on the stack will go out of scope and are automatically deallocated.
• Much faster to allocate in comparison to variables on the heap.
• Implemented with an actual stack data structure.
• Stores local data, return addresses, used for parameter passing.
• Can have a stack overflow when too much of the stack is used (mostly from infinite or too deep recursion, very large allocations).
• Data created on the stack can be used without pointers.
• You would use the stack if you know exactly how much data you need to allocate before compile time and it is not too big.
• Usually has a maximum size already determined when your program starts.
• A collection of data needed for a single method is called a stack frame

Heap:

• Stored in RAM just like the stack.
• In C++, variables on the heap must be destroyed manually and never fall out of scope. The data is freed with delete, delete[], or free.
• Slower to allocate in comparison to variables on the stack.
• Used on demand to allocate a block of data for use by the program.
• Can have fragmentation when there are a lot of allocations and deallocations.
• In C++ or C, data created on the heap will be pointed to by pointers (from the stack) and allocated with new or malloc respectively.
• Can have allocation failures if too big of a buffer is requested to be allocated.
• You would use the heap if you don’t know exactly how much data you will need at run time or if you need to allocate a lot of data.
• Responsible for memory leaks.

Example:

int foo()
{
  char *pBuffer; //<--nothing allocated yet (excluding the pointer itself, which is allocated here on the stack).
  bool b = true; // Allocated on the stack.
  if(b)
  {
    //Create 500 bytes on the stack
    char buffer[500];

    //Create 500 bytes on the heap
    pBuffer = new char[500];

   }//<-- buffer is deallocated here, pBuffer is not
}//<--- oops there's a memory leak, I should have called delete[] pBuffer;

why would an object be created on the heap or stack?

In computer science, whether an object is created on the heap or the stack depends on several factors, including object size, lifetime, dynamic allocation needs, sharing requirements, and polymorphism.

1. Object size: If the object is small, it can be created on the stack, but if it’s large, then it should be created on the heap.
2. Lifetime: If the object’s lifetime needs to transcend beyond the block/scope where it was created, objects should be created on the heap. Alternatively, If the object’s lifetime is within the context of the block/scope where it was created, objects can be created on the stack.
3. Dynamic allocation: Heap objects can be allocated dynamically at runtime, while stack objects need to be allocated at compile time.
4. Sharing: Heap objects can be shared between multiple threads, while stack objects are local to a single thread.
5. Polymorphism: Creating objects on the heap allows for polymorphism, where objects of different derived classes can be referenced using a base class pointer.