Call stack behavior in C++ - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the call stack in C++?

The call stack is a special area in memory that stores information about active functions or methods. It keeps track of where each function should return after it finishes.

beginner

What happens when a function is called in terms of the call stack?

When a function is called, a new stack frame is created and pushed onto the call stack. This frame holds the function's parameters, local variables, and return address.

intermediate

Explain what a stack frame contains.

A stack frame contains the function's parameters, local variables, and the return address to know where to continue after the function finishes.

beginner

What happens to the call stack when a function returns?

When a function returns, its stack frame is popped off the call stack, and the program continues execution from the return address stored in the previous stack frame.

intermediate

What is a stack overflow and when can it happen?

A stack overflow happens when the call stack grows beyond its limit, usually because of too many nested function calls or infinite recursion, causing the program to crash.

What does the call stack store when a function is called?

A Only the function's name

B Global variables only

C The entire program's code

D The function's parameters, local variables, and return address

The call stack stores the function's parameters, local variables, and return address in a stack frame.

What happens to the call stack when a function finishes execution?

A The current stack frame is popped

B A new stack frame is pushed

C The stack is cleared completely

D Nothing changes

When a function finishes, its stack frame is popped off the call stack.

Which of these can cause a stack overflow?

A Declaring local variables

B Too many nested function calls

C Using global variables

D Calling functions once

Too many nested function calls or infinite recursion can cause the call stack to overflow.

Where does the program continue after a function returns?

A At a random memory location

B At the start of the program

C At the return address stored in the previous stack frame

D At the end of the program

The program continues at the return address stored in the previous stack frame.

What is NOT stored in a stack frame?

A Global variables

B Function parameters

C Return address

D Local variables

Global variables are stored in a different memory area, not in the stack frame.

Describe the lifecycle of a function call in terms of the call stack.

Think about what happens when you call a function and when it finishes.

Explain what causes a stack overflow and how it relates to the call stack.

Imagine calling functions inside functions without stopping.

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