Call stack behavior in C++ - Step-by-Step Execution

Concept Flow - Call stack behavior

Program starts

↓

Function called

↓

Push frame on stack

↓

Execute function body

↓

Function calls another function?

Yes→Repeat push frame

No↓

Function returns

↓

Pop frame from stack

↓

Return to caller or end program

This flow shows how each function call adds a frame to the stack, runs, then removes the frame when done.

Execution Sample

C++

int add(int a, int b) {
    return a + b;
}

int main() {
    int result = add(2, 3);
    return 0;
}

This code calls add(2, 3), showing how the call stack manages the function call and return.

Execution Table

Step	Action	Call Stack Frames	Top Frame Variables	Output/Return Value
1	Program starts	[]	None	None
2	main() called	[main]	None	None
3	add(2, 3) called inside main	[main, add]	a=2, b=3	None
4	add returns a+b=5	[main]	None	5
5	main stores result=5	[main]	result=5	None
6	main returns 0	[]	None	0
7	Program ends	[]	None	None

💡 Program ends after main returns, call stack is empty.

Variable Tracker

Variable	Start	After Step 3	After Step 4	After Step 5	Final
a	N/A	2	N/A	N/A	N/A
b	N/A	3	N/A	N/A	N/A
result	N/A	N/A	N/A	5	5

Key Moments - 3 Insights

Why does the call stack grow when a function is called?

Each function call creates a new frame on the stack to store its variables and return address, as shown in step 3 of the execution_table.

What happens to the variables of a function after it returns?

The function's stack frame is popped off, so its variables are removed from the stack, as seen in step 4 where add's frame is removed.

Why is the call stack empty after main returns?

Because main is the first function called and the last to return, once it returns, no frames remain on the stack, shown in step 6 and 7.

Visual Quiz - 3 Questions

Look at the execution_table at step 3, what variables are stored in the top stack frame?

A a=2, b=3

B result=5

C None

D a=5, b=0

💡 Hint

Check the 'Top Frame Variables' column at step 3 in the execution_table.

At which step does the add function return its value and its frame is popped?

A Step 2

B Step 5

C Step 4

D Step 6

💡 Hint

Look for when the call stack changes from [main, add] to [main] in the execution_table.

If main called another function before add, how would the call stack look at step 3?

A [main, add]

B [main, other_function, add]

C [main, other_function]

D [add]

💡 Hint

Each function call adds one frame on top; the stack grows with each call.

Concept Snapshot

Call stack stores function calls in order.
Each call adds a frame with variables.
When function returns, frame is removed.
Stack empties after main returns.
Helps track where to return next.

Full Transcript

The call stack is a structure that keeps track of function calls. When the program starts, the stack is empty. Calling main adds its frame. Inside main, calling add pushes add's frame with variables a=2 and b=3. When add returns, its frame is popped, returning 5 to main. Main stores result=5, then returns 0, popping its frame and ending the program. Variables exist only while their function's frame is on the stack. This process ensures the program knows where to return after each call.

Practice

1. What does the call stack do when a function is called in C++?

easy

A. It adds a new frame for the function call on top of the stack.

B. It removes the last function call from the stack.

C. It clears all previous function calls.

D. It pauses the program execution permanently.

Solution

1. Step 1: Understand function call behavior

   When a function is called, the program needs to remember where to return after the function finishes.

2. Step 2: Role of the call stack

   The call stack adds a new frame on top to store this information and local variables.

3. Final Answer:

   It adds a new frame for the function call on top of the stack. -> Option A

4. Quick Check:

   Function call = add frame [OK]

Hint: Call means add frame; return means remove frame [OK]

Common Mistakes:

• Thinking the stack removes frames on function call
• Believing the stack clears all calls at once
• Confusing call stack with program pause

2. Which of the following C++ code snippets correctly shows a function call that affects the call stack?

easy

A. int main() { return 0; } void foo() { foo(); }

B. void foo() { main(); } int main() { return 0; }

C. void foo() {} int main() { foo(); return 0; }

D. int main() { int x = 5; }

Solution

1. Step 1: Identify valid function call from main

   void foo() {} int main() { foo(); return 0; } calls foo() from main, which adds a frame to the call stack.

2. Step 2: Check other options for correctness

   void foo() { main(); } int main() { return 0; } calls main() from foo(), which is invalid as main should not be called explicitly. int main() { return 0; } void foo() { foo(); } has foo calling itself but foo is not called from main, so no stack change from main. int main() { int x = 5; } has no function calls.

3. Final Answer:

   void foo() {} int main() { foo(); return 0; } -> Option C

4. Quick Check:

   Valid call from main = void foo() {} int main() { foo(); return 0; } [OK]

Hint: Look for main calling another function directly [OK]

Common Mistakes:

• Thinking main can be called like a normal function
• Ignoring function call order
• Confusing declaration with call

3. What is the output of this C++ program?

#include <iostream>

void print(int n) {
  if (n == 0) return;
  print(n - 1);
  std::cout << n << " ";
}

int main() {
  print(3);
  return 0;
}

medium

A. 3 2 1

B. 1 2 3

C. 0 1 2 3

D. 3 2 1 0

Solution

1. Step 1: Trace recursive calls

   print(3) calls print(2), which calls print(1), which calls print(0). At print(0), it returns immediately.

2. Step 2: Print after returning from recursion

   After print(0) returns, print(1) prints '1 ', then print(2) prints '2 ', then print(3) prints '3 '.

3. Final Answer:

   1 2 3 -> Option B

4. Quick Check:

   Recursion prints after calls = 1 2 3 [OK]

Hint: Print happens after recursion call returns [OK]

Common Mistakes:

• Printing before recursive call instead of after
• Including 0 in output incorrectly
• Confusing order of prints in recursion

4. The following code causes a runtime error. What is the main cause?

void recurse(int n) {
  if (n > 0) {
    recurse(n + 1);
  }
}

int main() {
  recurse(1);
  return 0;
}

medium

A. Stack overflow due to infinite recursion increasing n.

B. Syntax error because of missing return statement.

C. No error; program runs and exits normally.

D. Variable n is not initialized.

Solution

1. Step 1: Analyze recursion condition

   The function calls recurse(n + 1) if n > 0, so n increases each call without stopping.

2. Step 2: Understand call stack effect

   Because n never reaches 0 or less, recursion never stops, causing stack frames to pile up until overflow.

3. Final Answer:

   Stack overflow due to infinite recursion increasing n. -> Option A

4. Quick Check:

   Infinite recursion = stack overflow [OK]

Hint: Check if recursion moves toward base case [OK]

Common Mistakes:

• Assuming recursion stops without base case
• Confusing syntax error with runtime error
• Ignoring infinite growth of parameter

5. Given this code, what will be the final value of result?

int factorial(int n) {
  if (n <= 1) return 1;
  return n * factorial(n - 1);
}

int main() {
  int result = factorial(4);
  return 0;
}

hard

A. 1

B. 10

C. 4

D. 24

Solution

1. Step 1: Understand factorial recursion

   factorial(4) calls factorial(3), factorial(3) calls factorial(2), factorial(2) calls factorial(1), which returns 1.

2. Step 2: Calculate return values step-by-step

   factorial(2) = 2 * 1 = 2; factorial(3) = 3 * 2 = 6; factorial(4) = 4 * 6 = 24.

3. Final Answer:

   24 -> Option D

4. Quick Check:

   4! = 24 [OK]

Hint: Multiply down from n to 1 recursively [OK]

Common Mistakes:

• Stopping recursion too early
• Adding instead of multiplying
• Confusing base case return value