Heap Memory

Heap memory is a larger memory space used to store objects and data that are not defined at compile time. It is used for dynamic memory allocation, which means that the size of the memory block is not known until runtime. Heap memory is also known as the dynamic memory or free store.

Stack Memory

Stack memory is a smaller memory space used to store data that is defined at compile time, such as local variables, function parameters, and return addresses. It is used for static memory allocation, which means that the size of the memory block is known at compile time. Stack memory is also known as the automatic memory.

Key Difference

The key difference between heap and stack memory is how they manage memory allocation and deallocation.

Heap memory is allocated and deallocated dynamically by the programmer. This means that the programmer is responsible for requesting and releasing memory from the heap. If the programmer forgets to release memory, a memory leak can occur, which can cause the program to crash or slow down.

On the other hand, stack memory is managed automatically by the system. The memory is automatically allocated when a function is called and automatically deallocated when the function returns. This makes it easier to manage memory, as the programmer does not have to worry about allocating and deallocating memory explicitly.

Examples

Example 1: Heap Memory

int* ptr = new int; // allocate memory on the heap
*ptr = 10; // store a value in the memory block
delete ptr; // release the memory

In this example, we allocate memory on the heap using the new keyword and store a value in the memory block. We then release the memory using the delete keyword.

Example 2: Stack Memory

int foo() {
  int x = 10; // allocate memory on the stack
  return x;
}

int main() {
  int y = foo(); // call the function
  // memory is automatically deallocated when function returns
  return 0;
}

In this example, we allocate memory on the stack by defining a local variable x inside the foo function. When the function returns, the memory is automatically deallocated. We then call the foo function from the main function and store the return value in the variable y.