Recursion and Memory: How to "See" the Call Stack (C++, Java, Python)

When you write a recursive function, you aren't just calling lines of code; you are building a data structure in your computer's memory called the Call Stack.

A common question for developers learning recursion is: If I have a local variable inside my function, how can I see what that variable holds in previous, unfinished recursive calls?

This guide breaks down the theory of stack frames and provides concrete ways to inspect them in C++, Java, and Python.

---

1. The Theory: What is a Stack Frame?

Every time a function is called, the system creates a specific block of memory known as a Stack Frame (or Activation Record).

Consider this simple recursive logic:

1. Function rec(0) is called.
2. It pauses and calls rec(1).
3. rec(1) pauses and calls rec(2).

When rec(2) is active, the first two function calls do not disappear. They are paused in the background. Their local variables are preserved in their respective stack frames, effectively "frozen" in memory until the inner calls return.

Key Concept: Local variables are unique to their specific frame. The variable v in rec(0) is stored at a completely different memory address than the variable v in rec(1).

---

2. C++: Two Ways to Inspect

In C++, you have two primary options: simulating the stack manually or using a system debugger.

Method A: The "Code-Only" Method (No Debugger)

If you cannot use a debugger, standard C++ does not allow you to access "previous" stack frames directly. You can simulate this by creating a manual history log using std::vector.

The Implementation:

Click to expand solution code

#include <iostream>
#include <vector>

// 1. Define a structure to hold the "snapshot" of a frame
struct FrameState {
    int i_value;
    int v_value;
};

// 2. Create a manual log
std::vector<FrameState> stack_log;

void rec(int i, int n) {
    if (i == n) {
        std::cout << "--- Recursion Bottom reached at i=" << i << " ---\n";
        // Iterate through our manual log to see previous states
        for (int k = 0; k < stack_log.size(); k++) {
            std::cout << "  Frame " << k << ": [i=" << stack_log[k].i_value
                      << ", v=" << stack_log[k].v_value << "]\n";
        }
        return;
    }

    int v = 10;

    // 3. "Push" current state to our log before recursing
    stack_log.push_back({i, v});

    rec(i + 1, n);

    // 4. "Pop" state when returning (optional)
    stack_log.pop_back();
}

int main() {
    rec(0, 3);
    return 0;
}

Method B: The Debugger Method (GDB)

For the most accurate view, use GDB. This allows you to pause the program and "walk" the actual system stack.

Steps:

1. Compile with debug symbols: g++ -g main.cpp -o app

2. Run GDB: gdb ./app

3. Set a breakpoint: break rec

4. Run: run

5. Inspecting Frames:

   • Use bt (backtrace) to see the list of paused functions.

   • Use frame <number> (e.g., frame 0) to switch to a previous function call.

   • Use info locals to see the variables i and v inside that specific frozen frame.

---

3. Java: Stack Inspection

In Java, you generally cannot access the local variables of previous frames without using the Debugger API (JDI), but you can easily inspect the Stack Trace (function names and line numbers) to see the recursion depth.

Using Thread.currentThread().getStackTrace():

public class RecursionTest {
    static void rec(int i, int n) {
        if (i == n) {
            System.out.println("--- Stack Trace at Bottom ---");
            // Get the current stack
            StackTraceElement[] stack = Thread.currentThread().getStackTrace();

            for (StackTraceElement frame : stack) {
                // Filter to only show our 'rec' function
                if (frame.getMethodName().equals("rec")) {
                    System.out.println("  Running: " + frame.getMethodName() + 
                                     " | Line: " + frame.getLineNumber());
                }
            }
            return;
        }
        rec(i + 1, n);
    }

    public static void main(String[] args) {
        rec(0, 3);
    }
}

Note: To see local variables in Java, you must use a debugger like the one in IntelliJ IDEA or Eclipse.

---

4. Python: Stack Inspection

Python provides powerful tools in the traceback and inspect modules to print the call stack directly from your code.

Using traceback.print_stack():

import traceback

def rec(i, n):
    if i == n:
        print("--- Python Stack Trace ---")
        # Prints the current call stack to the console
        traceback.print_stack()
        return

    v = 10
    rec(i + 1, n)

rec(0, 3)

Using inspect (Advanced): Python's inspect module actually allows you to see local variables of previous frames, unlike standard Java or C++.

import inspect

def rec(i, n):
    if i == n:
        print("--- Inspecting Previous Frames ---")
        # inspect.stack() returns a list of frame records
        for frame_info in inspect.stack():
            if frame_info.function == 'rec':
                # frame_info[0] is the frame object
                # .f_locals gives a dictionary of local variables
                locals_dict = frame_info[0].f_locals
                print(f"Function rec found: i={locals_dict.get('i')}")
        return

    rec(i + 1, n)

rec(0, 3)

---

Summary

Language	Code-Based Inspection	Debugger Tool
C++	Use std::vector to log state manually.	GDB (Best for full variable inspection).
Java	Thread.currentThread().getStackTrace().	JDB or IntelliJ/Eclipse Debugger.
Python	traceback.print_stack() or inspect module.	PDB (import pdb; pdb.set_trace()).