How Stack Grows and Shrinks | Master Beginner-Friendly Guide with Examples (2026)

How stack grows and shrinks explained with real-life examples and C code. Learn stack memory growth and shrinkage in an easy beginner-friendly way.

A Real-Life Story to Understand the Stack

Imagine you are in a restaurant kitchen. The chef keeps plates stacked one over another:

• When a new customer order comes, the chef adds a new plate on top of the pile.
• When an order is served, the chef removes the top plate first.

The chef never touches the plates at the bottom until the top ones are removed. This is exactly how the stack in memory works when your program runs.

• Every new function call is like placing a new plate on the stack (the stack grows).
• When the function finishes, it’s like removing that plate (the stack shrinks).

When learning memory management in programming, one of the most important concepts is the stack. Many beginners hear terms like stack grows and stack shrinks but find them confusing. This article explains the concept in a clear, step-by-step, beginner-friendly way, so you understand how the stack works in real programs.

What is the Stack?

The stack is a special area of memory used by programs to keep track of function calls, local variables, and return addresses. Think of it as a pile of plates:

• You add a new plate on top (push).
• You remove the top plate when it’s no longer needed (pop).

This “last-in, first-out” (LIFO) behavior makes the stack very efficient.

How the Stack Grows

The stack grows when:

1. A new function is called.
2. Local variables are created inside that function.
3. Temporary data (like function arguments or return addresses) are stored.

Example in C:

#include <stdio.h>

void displayNumber(int x) {
    int y = x + 5;  // local variable stored on the stack
    printf("Value: %d\n", y);
}

int main() {
    displayNumber(10);  // stack grows here
    return 0;
}

• When main() calls displayNumber(10), memory for x and y is added to the stack.
• This is called stack frame allocation.

So, each function call creates a new stack frame, and the stack grows downward in memory (on most systems).

How the Stack Shrinks

The stack shrinks when:

1. A function finishes execution.
2. Its local variables and temporary data are no longer needed.
3. The system pops the function’s stack frame, releasing memory automatically.

Continuing with the example above:

• After displayNumber(10) finishes, the memory used by x and y is removed from the stack.
• The stack pointer moves back, and the program returns to main().

This process is automatic — the programmer doesn’t need to free stack memory manually.

Why Understanding Stack Grows and Shrinks is Important

1. Avoiding Stack Overflow – If too many functions are called without finishing, the stack memory can run out, causing a stack overflow error.
2. Debugging Programs – Many runtime errors can be understood by analyzing the stack.
3. Efficient Programming – Understanding how the stack works helps in writing better functions and managing recursion.

Key Differences Between Stack Stack Grows and Shrinks

Aspect	Stack Growth	Stack Shrinkage
When it happens	On function call or variable allocation	On function return or variable release
Memory effect	Increases stack size	Decreases stack size
Programmer control	Automatic, managed by system	Automatic, managed by system

Example Code: How the Stack Stack Grows and Shrinks

//code for Stack Grows and Shrinks
#include <stdio.h>

void thirdFunction() {
    int c = 30;  // local variable stored on stack
    printf("➡ Entering thirdFunction (stack grows, variable c = %d)\n", c);
    printf("⬅ Leaving thirdFunction (stack shrinks)\n");
}

void secondFunction() {
    int b = 20;  // local variable stored on stack
    printf("➡ Entering secondFunction (stack grows, variable b = %d)\n", b);

    thirdFunction();  // stack grows again

    printf("⬅ Leaving secondFunction (stack shrinks)\n");
}

void firstFunction() {
    int a = 10;  // local variable stored on stack
    printf("➡ Entering firstFunction (stack grows, variable a = %d)\n", a);

    secondFunction();  // stack grows again

    printf("⬅ Leaving firstFunction (stack shrinks)\n");
}

int main() {
    printf("➡ Program started (main function stack frame created)\n");

    firstFunction();  // stack grows again

    printf("⬅ Back to main (stack shrinks after all calls)\n");
    return 0;
}

Expected Output for Stack Grows and Shrinks

When you run the program, the output shows clearly how the stack grows when a function is entered and shrinks when the function finishes:

➡ Program started (main function stack frame created)
➡ Entering firstFunction (stack grows, variable a = 10)
➡ Entering secondFunction (stack grows, variable b = 20)
➡ Entering thirdFunction (stack grows, variable c = 30)
⬅ Leaving thirdFunction (stack shrinks)
⬅ Leaving secondFunction (stack shrinks)
⬅ Leaving firstFunction (stack shrinks)
⬅ Back to main (stack shrinks after all calls)

How This Code Matches the Story

• Just like stacking plates in a kitchen:
  • thirdFunction() is the top plate → it must be removed first.
  • Then secondFunction() → removed after third.
  • Finally firstFunction() → removed last.

That’s why the stack follows a Last-In, First-Out (LIFO) order.

Advantages of Stack Grows and Shrinks

1. Automatic Memory Management – The stack grows and shrinks automatically without programmer effort.
2. Fast Execution – Stack operations (push/pop) are very efficient compared to heap allocations.
3. Predictable Behavior – Memory is released as soon as a function returns, making the program more reliable.
4. Good for Function Calls – Ideal for storing local variables, return addresses, and function arguments.

Disadvantages of Stack Grows and Shrinks

1. Limited Size – Stack memory is small compared to heap memory. Too many nested function calls may cause stack overflow.
2. Temporary Lifetime – Data in the stack is destroyed once the function ends, so it cannot be shared globally.
3. No Manual Control – Unlike heap memory, you cannot manually manage stack memory size.
4. Recursive Risks – Deep recursion can quickly exhaust stack space.

Applications of Stack in Programming

1. Function Call Management – Each function call creates a new stack frame that stores local variables and return addresses.
2. Recursion – The stack allows recursive functions to keep track of multiple calls at once.
3. Expression Evaluation – Compilers and interpreters use stacks for evaluating arithmetic expressions.
4. Backtracking Algorithms – Stacks are used in solving mazes, puzzles, and depth-first search (DFS).
5. Interrupt Handling in OS – Operating systems use the stack to save the current state before switching tasks.

Real-World Example

• Web Browsers → Use stacks for the Back/Forward navigation system.
• Programming Languages → C, C++, Java, and Python rely heavily on stack growth/shrinkage during function calls.
• Embedded Systems → Use stacks for managing tasks, interrupts, and low-level function calls efficiently.

Frequently Asked Questions (FAQ) of Stack Grows and Shrinks

You can also Visit other tutorials of Embedded Prep 

• Multithreading in C++
• Multithreading Interview Questions
• Multithreading in Operating System
• Multithreading in Java
• POSIX Threads pthread Beginner’s Guide in C/C++
• Speed Up Code using Multithreading
• Limitations of Multithreading
• Common Issues in Multithreading
• Multithreading Program with One Thread for Addition and One for Multiplication
• Advantage of Multithreading
• Disadvantages of Multithreading
• Applications of Multithreading: How Multithreading Makes Modern Software Faster and Smarter”
• Master CAN Bus Interview Questions 2025
• What Does CAN Stand For in CAN Bus?
• CAN Bus Message Filtering Explained
• CAN Bus Communication Between Nodes With Different Bit Rates
• How Does CAN Bus Handle Message Collisions
• Message Priority Using Identifiers in CAN Protocol