Introduction

In programming, stack and heap are two important memory areas used by a running program.

Both stack and heap are part of memory, but they are used for different purposes. Understanding them helps students understand how variables, functions, objects, and dynamic data are stored while a program runs.

Students do not need to master low-level memory management immediately, but they should understand the basic difference between stack and heap because it affects program performance, memory usage, and error handling.

Easy Real-Life Example

Plate 1 added
Plate 2 added
Plate 3 added

Plate 3 removed first
Plate 2 removed next
Plate 1 removed last

Stack memory works in a similar way. The most recent function call is completed first, and then control returns to the previous function.

Heap is useful when data needs to be created dynamically while the program is running.

What is Stack Memory?

Stack memory is a memory area used to store temporary data related to function calls.

When a function is called, the program creates a small memory block for that function. This block may store local variables, parameters, return information, and temporary values.

When the function finishes, the memory used by that function is automatically released.

Example: Stack Memory Concept

/*
This example shows local variables inside a function.
These variables are usually stored in stack memory.
*/

FUNCTION addNumbers()
    DECLARE a AS INTEGER = 10
    DECLARE b AS INTEGER = 20
    DECLARE sum AS INTEGER = a + b

    DISPLAY sum
END FUNCTION

ENTRY POINT
    CALL addNumbers()
END ENTRY POINT

Expected Output

30

Here, variables a, b, and sum exist while the function is running. After the function ends, their temporary memory can be released.

How Stack Works

Stack memory follows the LIFO rule, which means Last-In, First-Out.

When functions call other functions, each function gets its own stack frame.

main() calls functionA()
functionA() calls functionB()
functionB() finishes first
functionA() continues
main() continues

Function Call Flow

FUNCTION functionB()
    DISPLAY "Inside functionB"
END FUNCTION

FUNCTION functionA()
    DISPLAY "Inside functionA"
    CALL functionB()
END FUNCTION

ENTRY POINT
    DISPLAY "Start main"
    CALL functionA()
    DISPLAY "End main"
END ENTRY POINT

Expected Output

Start main
Inside functionA
Inside functionB
End main

Even though main starts first, functionB finishes before functionA, and functionA finishes before main. This is stack-like behavior.

Stack Frame

A stack frame is a block of memory created for one function call.

Each time a function is called, a stack frame may be added to the stack. When the function ends, its stack frame is removed.

Stack when functionB is running:

Top → functionB frame
      functionA frame
      main frame

When functionB finishes, its frame is removed first.

What is Heap Memory?

Heap memory is a memory area used for dynamic memory allocation.

Dynamic memory means memory that is requested while the program is running. Heap is commonly used for objects, large data structures, and data whose size may not be known in advance.

Example: Heap Memory Concept

/*
This example represents creating an object dynamically.
The actual object is commonly stored in heap memory.
*/

CLASS Student
    PROPERTY name
    PROPERTY marks
END CLASS

ENTRY POINT
    CREATE studentObject AS Student
    SET studentObject.name = "Riya"
    SET studentObject.marks = 90

    DISPLAY studentObject.name
    DISPLAY studentObject.marks
END ENTRY POINT

Expected Output

Riya
90

In many programming languages, the reference to the object may be stored in stack memory, while the actual object data is stored in heap memory.

Stack vs Heap: Main Difference

Stack and heap are both memory areas, but they are used differently.

Visual Memory Layout Idea

A running program may organize memory into different sections such as code area, data area, stack, and heap.

Program Memory Layout Idea:

+----------------------------+
| Code Area                  |
| Program instructions       |
+----------------------------+
| Data Area                  |
| Global/static data         |
+----------------------------+
| Heap                       |
| Dynamic objects and data   |
| Grows as needed            |
+----------------------------+
| Free Space                 |
+----------------------------+
| Stack                      |
| Function calls and locals  |
| Grows with function calls  |
+----------------------------+

This is a simplified model for beginners. Actual memory layout can differ depending on language, compiler, runtime, and operating system.

Example: Stack and Heap Together

Many programs use both stack and heap at the same time.

/*
This example shows a reference and an object.
*/

CLASS Product
    PROPERTY name
    PROPERTY price
END CLASS

FUNCTION createProduct()
    CREATE productRef AS Product
    SET productRef.name = "Keyboard"
    SET productRef.price = 500

    RETURN productRef
END FUNCTION

ENTRY POINT
    DECLARE item = createProduct()

    DISPLAY item.name
    DISPLAY item.price
END ENTRY POINT

Expected Output

Keyboard
500

Conceptually:

Lifetime of Stack Variables

Stack variables usually live only while their function is running.

FUNCTION calculateTotal()
    DECLARE total AS INTEGER = 100
    DISPLAY total
END FUNCTION

Here, total is a local variable. Once calculateTotal() finishes, total is no longer needed and its stack memory can be released.

Lifetime of Heap Data

Heap data can live longer than a single function call.

If a program creates an object and passes its reference to other parts of the program, the object may continue to exist as long as it is still reachable or not released.

CREATE userObject
PASS userObject TO another function
STORE userObject IN a list
USE userObject later

In garbage-collected languages, unused heap objects may be cleaned automatically by the runtime. In manual memory languages, the programmer may need to release heap memory explicitly.

Why Stack is Usually Faster

Stack memory is usually faster because allocation and deallocation follow a simple order.

When a function starts, its stack frame is added. When the function ends, the stack frame is removed. This predictable behavior makes stack memory efficient.

Function starts  → stack frame added
Function ends    → stack frame removed

The program does not usually need to search for a suitable free memory block in the stack.

Why Heap is More Flexible

Heap memory is more flexible because memory can be requested at runtime depending on program needs.

This is useful when:

Examples:
- A list of users loaded from a file
- A shopping cart that grows as items are added
- A tree or linked list created at runtime
- Objects created based on user input

Stack Overflow

A stack overflow happens when stack memory becomes full.

This commonly happens when a function keeps calling itself without stopping, usually due to missing or incorrect base condition in recursion.

Example: Infinite Recursion Problem

/*
This function has no stopping condition.
It can cause stack overflow.
*/

FUNCTION callAgain()
    CALL callAgain()
END FUNCTION

ENTRY POINT
    CALL callAgain()
END ENTRY POINT

Each function call creates a new stack frame. If the function never stops, too many stack frames are created and the stack may become full.

Better Recursive Function

/*
This function has a base condition.
*/

FUNCTION countDown(n)
    IF n == 0 THEN
        RETURN
    END IF

    DISPLAY n
    CALL countDown(n - 1)
END FUNCTION

ENTRY POINT
    CALL countDown(5)
END ENTRY POINT

Expected Output

5
4
3
2
1

The base condition prevents infinite recursion.

Memory Leak

A memory leak happens when heap memory is allocated but not released even after it is no longer needed.

Over time, memory leaks can make a program slower or cause it to run out of memory.

Program creates object
Program stops using object
Object memory is not released
Memory remains occupied unnecessarily

In languages with manual memory management, programmers must be careful to free unused heap memory. In languages with garbage collection, programmers should still avoid keeping unnecessary references.

Garbage Collection and Heap

Some languages use garbage collection to automatically clean unused heap memory.

Garbage collection finds objects that are no longer reachable and frees their memory.

Object created in heap
Reference points to object
Reference is removed
Object becomes unreachable
Garbage collector may clean it

Example: Student Object Memory Concept

/*
Student object example.
*/

CLASS Student
    PROPERTY name
    PROPERTY age
END CLASS

FUNCTION showStudent()
    CREATE s AS Student
    SET s.name = "Aman"
    SET s.age = 20

    DISPLAY s.name
    DISPLAY s.age
END FUNCTION

ENTRY POINT
    CALL showStudent()
END ENTRY POINT

Conceptually:

Example: Local Variable vs Object

/*
Local variables are usually stack-based.
Objects are often heap-based.
*/

FUNCTION calculate()
    DECLARE x AS INTEGER = 10
    DECLARE y AS INTEGER = 20
    DECLARE result AS INTEGER = x + y

    DISPLAY result
END FUNCTION

In this example, x, y, and result are local values used only inside calculate().

FUNCTION createUser()
    CREATE user AS UserObject
    SET user.name = "Riya"

    RETURN user
END FUNCTION

In this example, the created user object may need heap memory because it may be used outside the function.

Stack and Heap in Different Languages

The exact implementation of stack and heap depends on the programming language and runtime environment.

The concept remains useful even when a language hides many memory details.

Stack Memory is Not the Same as Stack Data Structure

Beginners may confuse stack memory with the stack data structure.

They are related by the LIFO idea, but they are not exactly the same topic.

Heap Memory is Not the Same as Heap Data Structure

Heap memory and heap data structure are also different concepts.

Why Stack and Heap Knowledge is Important

Understanding stack and heap helps students write better programs and understand how programs behave internally.

Common Beginner Mistakes

Best Practices for Stack and Heap Usage

Prerequisites Before Learning Stack and Heap

Students should understand the following topics before learning stack and heap deeply:

Trace Table Example: Function Calls and Stack

Let us trace stack behavior in a simple program.

FUNCTION second()
    DISPLAY "Second"
END FUNCTION

FUNCTION first()
    DISPLAY "First"
    CALL second()
END FUNCTION

ENTRY POINT
    DISPLAY "Main"
    CALL first()
END ENTRY POINT

Practice Activity: Identify Stack or Heap

Identify whether the following are commonly related to stack or heap.

1. Local variable inside a function
2. Function call information
3. Dynamically created object
4. Large list created at runtime
5. Recursive function calls
6. Object that is shared across multiple functions

Sample Answers

1. Stack
2. Stack
3. Heap
4. Heap
5. Stack
6. Heap

Mini Quiz

Interview Questions on Stack and Heap

Quick Summary