Call stack behavior - Mini Project: Build & Apply

Call Stack Behavior

📖 Scenario: Imagine you are baking a layered cake. Each layer must be added one after another, and you can only add the next layer after finishing the previous one. This is similar to how the call stack works in programming, where functions wait for others to finish before continuing.

🎯 Goal: You will write a simple C program with three functions calling each other. You will observe how the call stack works by printing messages when entering and exiting each function.

📋 What You'll Learn

Create three functions named first, second, and third.

Each function should print a message when it starts and when it ends.

The first function should call second, and second should call third.

The main function should call first.

Print the messages exactly as specified.

💡 Why This Matters

🌍 Real World

Understanding call stack behavior helps debug programs and understand how function calls work in real applications like games, web servers, and calculators.

💼 Career

Many programming jobs require understanding how functions call each other and how the call stack manages these calls to write efficient and bug-free code.

1

Create the third function

Write a function called third that prints "Entering third" when it starts and "Exiting third" when it ends.

C

#include 

void third() {
    // Your code here
}

int main() {
    return 0;
}

Hint

Use printf to print messages inside the third function.

2

Create the second function that calls third

Write a function called second that prints "Entering second" when it starts, calls the third function, then prints "Exiting second" when it ends.

C

#include 

void third() {
    printf("Entering third\n");
    printf("Exiting third\n");
}

void second() {
    // Your code here
}

int main() {
    return 0;
}

Hint

Call the third() function between the two printf statements.

3

Create the first function that calls second

Write a function called first that prints "Entering first" when it starts, calls the second function, then prints "Exiting first" when it ends.

C

#include 

void third() {
    printf("Entering third\n");
    printf("Exiting third\n");
}

void second() {
    printf("Entering second\n");
    third();
    printf("Exiting second\n");
}

void first() {
    // Your code here
}

int main() {
    return 0;
}

Hint

Call the second() function between the two printf statements.

4

Call first from main and print the output

In the main function, call the first function. Then compile and run the program to see the messages showing the call stack behavior.

C

#include 

void third() {
    printf("Entering third\n");
    printf("Exiting third\n");
}

void second() {
    printf("Entering second\n");
    third();
    printf("Exiting second\n");
}

void first() {
    printf("Entering first\n");
    second();
    printf("Exiting first\n");
}

int main() {
    // Your code here
}

Hint

Call first() inside main() and run the program to see the order of messages.

Practice

1. What does the call stack do in a C program?

easy

A. Handles input and output operations

B. Stores global variables permanently

C. Manages memory allocation for dynamic data

D. Keeps track of function calls and local variables

Solution

1. Step 1: Understand the role of the call stack

   The call stack stores information about active function calls and their local variables during program execution.

2. Step 2: Differentiate from other memory areas

   Global variables and dynamic memory are stored elsewhere, not on the call stack.

3. Final Answer:

   Keeps track of function calls and local variables -> Option D

4. Quick Check:

   Call stack = function calls + locals [OK]

Hint: Call stack tracks active functions and locals [OK]

Common Mistakes:

• Confusing call stack with heap memory
• Thinking global variables are on the stack
• Assuming call stack manages I/O

2. Which of the following is the correct way to declare a function in C that will be called and added to the call stack?

easy

A. void myFunction() { /* code */ }

B. function myFunction() { /* code */ }

C. def myFunction() { /* code */ }

D. func myFunction() { /* code */ }

Solution

1. Step 1: Identify correct C function syntax

   In C, functions are declared with a return type, name, and parentheses, e.g., void myFunction().

2. Step 2: Recognize incorrect syntax

   Keywords like function, def, or func are not valid in C.

3. Final Answer:

   void myFunction() { /* code */ } -> Option A

4. Quick Check:

   C function declaration uses return type + name [OK]

Hint: C functions start with return type, no keywords like def [OK]

Common Mistakes:

• Using Python or JavaScript keywords in C
• Omitting return type in function declaration
• Using incorrect braces or parentheses

3. What will be the output of this C program?

void func(int n) {
    if (n == 0) return;
    printf("%d ", n);
    func(n - 1);
}

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

medium

A. 3 2 1

B. 3 2 1 0

C. 0 1 2 3

D. 1 2 3

Solution

1. Step 1: Trace the recursive calls

   The function prints the current value of n, then calls itself with n-1 until n is 0.

2. Step 2: Determine printed values

   It prints 3, then 2, then 1, then stops before printing 0.

3. Final Answer:

   3 2 1 -> Option A

4. Quick Check:

   Print before recursion = descending order [OK]

Hint: Print before recursive call means descending output [OK]

Common Mistakes:

• Assuming print happens after recursion
• Including zero in output incorrectly
• Confusing order of prints

4. Consider this code snippet:

void foo() {
    int x = 5;
    bar();
}

void bar() {
    printf("%d", x);
}

int main() {
    foo();
    return 0;
}

What is the error here?

medium

A. Missing semicolon after bar() call

B. Function foo() is missing a return type

C. Variable x is not declared in bar()'s scope

D. main() should return void

Solution

1. Step 1: Check variable scope

   Variable x is declared inside foo(), so it is local to foo() and not visible in bar().

2. Step 2: Identify the error cause

   bar() tries to print x, but x is undefined in bar(), causing a compile error.

3. Final Answer:

   Variable x is not declared in bar()'s scope -> Option C

4. Quick Check:

   Local variables are not shared across functions [OK]

Hint: Local variables can't be accessed outside their function [OK]

Common Mistakes:

• Thinking local variables are global
• Ignoring variable scope rules
• Assuming implicit variable sharing

5. Given this recursive function:

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

int main() {
    int result = factorial(4);
    printf("%d", result);
    return 0;
}

How many call stack frames are active at the deepest point during execution?

hard

A. 3

B. 4

C. 5

D. 1

Solution

1. Step 1: Count recursive calls for factorial(4)

   Calls happen for n=4, 3, 2, and 1 (base case triggers at n=1).

2. Step 2: Determine deepest call stack frames

   At n=1, the deepest call, there are 4 active frames: factorial(4), factorial(3), factorial(2), and factorial(1).

3. Final Answer:

   4 -> Option B

4. Quick Check:

   Number of calls = 4 frames [OK]

Hint: Count calls including base case, exclude main [OK]

Common Mistakes:

• Counting main() as a call stack frame for this question
• Off-by-one error in counting frames
• Assuming base case does not add a frame