Stack overflow detection in Embedded C - Mini Project: Build & Apply

Stack Overflow Detection

📖 Scenario: You are working on a small embedded system that uses a fixed-size stack to store data temporarily. To keep the system safe, you want to detect if the stack goes beyond its limit, which is called a stack overflow.Imagine the stack as a stack of plates. If you add too many plates, the stack will fall. We want to check if the stack is full before adding more plates.

🎯 Goal: Build a simple program that creates a stack array, sets a maximum size, and checks if the stack is full before pushing new data. If the stack is full, it should print a message saying "Stack Overflow detected!".

📋 What You'll Learn

Create an integer array called stack with size 5.

Create an integer variable called top to track the current top index of the stack.

Create an integer constant called MAX_SIZE and set it to 5.

Write a function called push that takes an integer value and adds it to the stack if there is space.

Inside push, check if top is equal to MAX_SIZE - 1 to detect overflow.

If overflow is detected, print "Stack Overflow detected!".

If there is space, add the value to the stack and update top.

In main, push 6 values to test the overflow detection.

Print the stack contents after all pushes.

💡 Why This Matters

🌍 Real World

Embedded systems often use fixed-size stacks for temporary data storage. Detecting stack overflow prevents crashes and data corruption.

💼 Career

Understanding stack overflow detection is important for embedded software developers to write safe and reliable code for devices like sensors, controllers, and IoT gadgets.

1

Create the stack array and top index

Create an integer array called stack with size 5 and an integer variable called top initialized to -1.

Embedded C

int stack[5];
int top = -1;
// Your code here

Hint

Think of top as the position of the last item in the stack. Starting at -1 means the stack is empty.

2

Define the maximum stack size

Create an integer constant called MAX_SIZE and set it to 5.

Embedded C

int stack[5];
int top = -1;
const int MAX_SIZE = 5;
// Your code here

Hint

This constant tells us the maximum number of items the stack can hold.

3

Write the push function with overflow check

Write a function called push that takes an integer value. Inside, check if top == MAX_SIZE - 1. If true, print "Stack Overflow detected!". Otherwise, increase top by 1 and add value to stack[top].

Embedded C

int stack[5];
int top = -1;
const int MAX_SIZE = 5;

void push(int value) {
    // Your code here
}

Hint

Check if the stack is full before adding a new value. Use printf to show the overflow message.

4

Test pushing values and print the stack

In main, push the values 10, 20, 30, 40, 50, and 60 using push. Then, print all values in stack from index 0 to top separated by spaces.

Embedded C

#include 

int stack[5];
int top = -1;
const int MAX_SIZE = 5;

void push(int value) {
    if (top == MAX_SIZE - 1) {
        printf("Stack Overflow detected!\n");
    } else {
        top++;
        stack[top] = value;
    }
}

int main() {
    // Your code here
    return 0;
}

Hint

Push six values to test overflow. Then print all values in the stack separated by spaces.

Practice

1.

What is the main purpose of stack overflow detection in embedded C?

easy

A. To increase the stack size dynamically

B. To prevent writing data beyond the stack's fixed size

C. To optimize CPU speed

D. To clear the stack memory automatically

Solution

1. Step 1: Understand stack overflow concept

   Stack overflow occurs when data is pushed beyond the stack's allocated size.

2. Step 2: Identify purpose of detection

   Detection helps prevent writing beyond stack limits, avoiding crashes and corruption.

3. Final Answer:

   To prevent writing data beyond the stack's fixed size -> Option B

4. Quick Check:

   Stack overflow detection = prevent overflow [OK]

Hint: Stack overflow detection stops writes beyond stack size [OK]

Common Mistakes:

• Thinking stack size can grow automatically
• Confusing overflow detection with CPU optimization
• Assuming stack clears itself on overflow

2.

Which of the following code snippets correctly checks for stack overflow before pushing a value?

int stack[10];
int sp = 0; // stack pointer
int value = 5;

// Check before push
if (____) {
    stack[sp++] = value;
}

easy

A. sp < 10

B. sp > 10

C. sp == 10

D. sp >= 10

Solution

1. Step 1: Understand stack pointer and size

   Stack size is 10, valid indices are 0 to 9, so sp must be less than 10 to push.

2. Step 2: Choose correct condition

   Condition 'sp < 10' ensures we don't write beyond array bounds.

3. Final Answer:

   sp < 10 -> Option A

4. Quick Check:

   Push only if sp less than stack size [OK]

Hint: Check sp < stack size before push [OK]

Common Mistakes:

• Using sp >= 10 allows overflow
• Using sp == 10 pushes out of bounds
• Using sp > 10 misses last valid index

3.

What will be the output of the following code snippet?

int stack[3];
int sp = 0;

void push(int val) {
    if (sp < 3) {
        stack[sp++] = val;
        printf("Pushed %d\n", val);
    } else {
        printf("Stack Overflow!\n");
    }
}

int main() {
    push(1);
    push(2);
    push(3);
    push(4);
    return 0;
}

medium

A. Pushed 1
Pushed 2
Pushed 3
Stack Overflow!

B. Pushed 1
Pushed 2
Pushed 3
Pushed 4

C. Stack Overflow!
Stack Overflow!
Stack Overflow!
Stack Overflow!

D. Pushed 1
Pushed 2
Stack Overflow!
Stack Overflow!

Solution

1. Step 1: Trace push calls and stack pointer

   First three pushes succeed because sp < 3; fourth push fails as sp == 3.

2. Step 2: Check output for each push

   Outputs "Pushed 1", "Pushed 2", "Pushed 3", then "Stack Overflow!" on last push.

3. Final Answer:

   Pushed 1 Pushed 2 Pushed 3 Stack Overflow! -> Option A

4. Quick Check:

   Pushes succeed until sp == 3, then overflow [OK]

Hint: Pushes stop when sp reaches stack size [OK]

Common Mistakes:

• Assuming push always succeeds
• Ignoring else branch output
• Confusing sp increment timing

4.

Identify the bug in the following stack push function that causes stack overflow detection to fail:

void push(int val) {
    if (sp <= 3) {
        stack[sp++] = val;
    } else {
        printf("Overflow detected\n");
    }
}

medium

A. sp is not incremented after push

B. Stack size is not checked at all

C. Condition should be sp < 3, not sp <= 3

D. printf statement is inside if block

Solution

1. Step 1: Analyze condition sp <= 3 with stack size 3

   sp can be 3, but valid indices are 0,1,2; sp=3 causes out-of-bounds write.

2. Step 2: Correct condition to prevent overflow

   Use sp < 3 to allow only valid indices 0 to 2.

3. Final Answer:

   Condition should be sp < 3, not sp <= 3 -> Option C

4. Quick Check:

   Use strict less than to avoid overflow [OK]

Hint: Use sp < stack size, not <=, to avoid overflow [OK]

Common Mistakes:

• Allowing sp == stack size causes overflow
• Not incrementing sp after push
• Misplacing overflow message

5.

You have a stack of size 5 and want to implement a safe push function that returns 0 on success and -1 on overflow. Which code snippet correctly implements this?

int stack[5];
int sp = 0;

int push(int val) {
    // Fill in condition
    if (__________) {
        stack[sp++] = val;
        return 0;
    } else {
        return -1;
    }
}

hard

A. sp > 5

B. sp <= 5

C. sp == 5

D. sp < 5

Solution

1. Step 1: Understand stack size and valid indices

   Stack size is 5, so valid indices are 0 to 4; sp must be less than 5 to push safely.

2. Step 2: Choose condition that prevents overflow

   Condition 'sp < 5' ensures no out-of-bounds write and returns 0 on success.

3. Final Answer:

   sp < 5 -> Option D

4. Quick Check:

   Push only if sp less than stack size [OK]

Hint: Return error if sp not less than stack size [OK]

Common Mistakes:

• Using sp <= 5 allows overflow
• Returning success on overflow
• Checking sp == 5 instead of less than