Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://www.geeksforgeeks.org/dsa/stack-vs-heap-memory-allocation/ below:

Stack vs Heap Memory Allocation

Last Updated : 26 Feb, 2025

In C, C++, and Java, memory can be allocated on either a stack or a heap. Stack allocation happens in the function call stack, where each function gets its own memory for variables. In C/C++, heap memory is controlled by programmer as there is no automatic garbage collection.

Stack allocation refers to the process of assigning memory for local variables and function calls in the call stack. It happens automatically when a function is called and is freed immediately when the function ends. Since memory is managed by the system, it is fast and efficient but has limited space compared to heap allocation. If too many function calls exceed the stack's capacity, it results in a stack overflow error.

• Memory is allocated in contiguous blocks within the call stack.
• The size of memory required is already known before execution.
• When a function is called, its local variables are allocated on the stack.
• Once the function finishes execution, the allocated memory is automatically freed.
• The programmer does not need to handle allocation or deallocation.
• Since stack memory is freed when a function completes, it is also called temporary memory allocation.

• Memory is available only while the function is running.
• Automatic deallocation occurs when the function ends.
• If the stack memory is full, an error like Java.lang.StackOverflowError occurs in Java and segmentation fault in C++.
• Safer than heap memory, as data can only be accessed by the owner thread.
• Faster than heap allocation due to automatic memory management.

Example Code:

int main() {
    
  // All these variables get memory
  // allocated on stack
  int a;
  int b[10];
  int n = 20;
  int c[n];
}

Heap memory is allocated dynamically during program execution. Unlike stack memory, heap memory is not freed automatically when a function ends. Instead, it requires manual deallocation (In C/C++) or a garbage collector (in Java or Python) to reclaim unused memory.

The name heap has no relation to the heap data structure; it simply refers to a large pool of memory available for dynamic allocation. Whenever an object is created, it is stored in heap memory, while references to these objects are stored in stack memory. Heap allocation is less safe than stack allocation because heap data is accessible by multiple threads, increasing the risk of data corruption and memory leaks if not handled properly.

Heap memory is divided into three categories, helping prioritize object storage and garbage collection:

1. Young Generation – Stores new objects. When this space is full, unused objects are removed by the garbage collector, and surviving objects move to the Old Generation.
2. Old (Tenured) Generation – Holds older objects that are no longer frequently used. These objects stay in memory unless explicitly removed.
3. Permanent Generation (PermGen) – Stores JVM metadata, such as runtime classes and application methods.

• If heap memory is full, JVM throws an error: java.lang.OutOfMemoryError.
• Unlike stack memory, automatic deallocation does not happen; a garbage collector is needed to free unused memory.
• Slower than stack memory due to manual allocation and garbage collection.
• Less thread-safe, as heap memory is shared among all threads.
• Typically larger in size compared to stack memory.
• Heap memory persists as long as the entire application is running.

Example Code:

int main()
{
   // This memory for 10 integers
   // is allocated on heap.
   int *ptr  = new int[10];
}

To Understand the difference between stack and heap memory allocation by observing how objects are created and managed in both cases using a class Emp for storing Employee details

Below is the implementation:

#include <bits/stdc++.h>
using namespace std;

class Emp {
public:
    int id;
    string emp_name;

    // Constructor to initialize employee details
    Emp(int id, string emp_name) {
        this->id = id;
        this->emp_name = emp_name;
    }
};

// Function to create and return an Emp object
Emp Emp_detail(int id, string emp_name) {
    return Emp(id, emp_name);
}

int main() {
    // Initializing employee details
    int id = 21;
    string name = "Maddy";

    // Creating an Emp object using the function
    Emp person_ = Emp_detail(id, name);
    
    return 0;
}

class Emp {
    int id;
    String emp_name;

    public Emp(int id, String emp_name) {
        this.id = id;
        this.emp_name = emp_name;
    }
}

public class Emp_detail {
    private static Emp Emp_detail(int id, String emp_name) {
        return new Emp(id, emp_name);
    }

    public static void main(String[] args) {
        int id = 21;
        String name = "Maddy";
        Emp person_ = null;
        person_ = Emp_detail(id, name);
    }
}

class Emp:
    # Constructor to initialize employee details
    def __init__(self, id, emp_name):
        self.id = id
        self.emp_name = emp_name

# Function to create and return an Emp object
def Emp_detail(id, emp_name):
    return Emp(id, emp_name)

if __name__ == "__main__":
    # Initializing employee details
    id = 21
    name = "Maddy"

    # Creating an Emp object using the function
    person_ = None
    person_ = Emp_detail(id, name)

class Emp {
    // Constructor to initialize employee details
    constructor(id, emp_name) {
        this.id = id;
        this.emp_name = emp_name;
    }
}

// Function to create and return an Emp object
function Emp_detail(id, emp_name) {
    return new Emp(id, emp_name);
}

// Initializing employee details
let id = 21;
let name = "Maddy";

// Creating an Emp object using the function
let person_ = null;
person_ = Emp_detail(id, name);

Based on the above example, we can draw the following conclusions:

• Heap Memory Allocation:
  • When the program starts, all runtime classes are stored in heap memory.
• Stack Memory Allocation:
  • The main method is stored in stack memory along with its local variables and reference variables.
  • The reference variable Emp of type Emp_detail is stored in the stack and points to the corresponding object in heap memory.
• Constructor Call and Memory Allocation:
  • The parameterized constructor Emp(int, string) is invoked from main, and its execution is allocated at the top of the stack.
  • Inside the constructor: The object reference is stored in stack memory, the primitive integer id is stored in stack memory and the string reference emp_name is stored in stack memory, but it points to the actual string stored in the string pool (heap memory).
• Function Call and Memory Allocation:
  • When Emp_detail() is called from main, a new stack frame is created on top of the previous stack frame.
  • The newly created Emp object and all its instance variables are stored in heap memory.

Pictorial representation as shown in the diagram below:

1. In a stack, the allocation and de-allocation are automatically done by the compiler whereas, in heap, it needs to be done by the programmer manually.
2. Handling the Heap frame is costlier than handling the stack frame.
3. Memory shortage problem is more likely to happen in stack whereas the main issue in heap memory is fragmentation.
4. Stack frame access is easier than the heap frame as the stack has a small region of memory and is cache-friendly but in the case of heap frames which are dispersed throughout the memory so it causes more cache misses.
5. A stack is not flexible, the memory size allotted cannot be changed whereas a heap is flexible, and the allotted memory can be altered.
6. Accessing time of heap takes is more than a stack.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4