Stack vs heap in embedded context - Practice Questions

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this embedded C code snippet?

Consider this embedded C code that uses stack and heap allocation. What will be printed?

Embedded C

#include <stdio.h>
#include <stdlib.h>

void func() {
    int stack_var = 10;
    int *heap_var = (int *)malloc(sizeof(int));
    *heap_var = 20;
    printf("Stack: %d, Heap: %d\n", stack_var, *heap_var);
    free(heap_var);
}

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

A Compilation error due to malloc

B Stack: 10, Heap: 20

C Stack: 10, Heap: 0

D Stack: 0, Heap: 20

💡 Hint

Remember that stack variables hold local values and heap variables are dynamically allocated.

The stack variable stack_var is set to 10. The heap variable heap_var is allocated memory and assigned 20. The printf prints both values correctly.

🧠 Conceptual

intermediate

Which statement best describes stack and heap usage in embedded systems?

In embedded systems, what is a key difference between stack and heap memory?

A Heap memory is only used for interrupt handling

B Heap is fixed size and fast; stack is dynamic and slower

C Both stack and heap are always the same size in embedded systems

D Stack is fixed size and fast; heap is dynamic but slower and fragmented

💡 Hint

Think about how memory is allocated and freed in stack vs heap.

The stack is usually a fixed-size memory region used for local variables and function calls, which is fast and managed automatically. The heap is dynamic memory that can grow and shrink but may cause fragmentation and is slower to allocate.

🔧 Debug

advanced

Why does this embedded C program crash?

Analyze the code below. Why does it crash on some embedded platforms?

Embedded C

#include <stdio.h>
#include <stdlib.h>

void func() {
    int *ptr;
    *ptr = 5;
    printf("Value: %d\n", *ptr);
}

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

A Pointer 'ptr' is uninitialized and points to random memory causing undefined behavior

B Stack overflow due to large local variable

C Heap memory is not freed causing memory leak

D Compilation error due to missing header

💡 Hint

Check how the pointer is used before assignment.

The pointer 'ptr' is declared but not initialized to point to valid memory. Writing to '*ptr' causes undefined behavior and likely a crash.

📝 Syntax

advanced

Which option correctly declares a heap allocation for an array in embedded C?

Choose the correct syntax to allocate an integer array of size 5 on the heap.

A int *arr = (int *)malloc(5 * sizeof(int));

B int arr = malloc(5 * sizeof(int));

C int *arr = malloc(sizeof(int[5]));

D int arr[5] = malloc(sizeof(int) * 5);

💡 Hint

Remember malloc returns a pointer and needs casting in embedded C.

Option A correctly allocates memory for 5 integers on the heap and casts the void pointer to int pointer. Other options have syntax errors or wrong types.

🚀 Application

expert

How many bytes are used on the stack after this function call in embedded C?

Given the function below, how many bytes of stack memory are used when example() is called on a 32-bit embedded system?

Embedded C

void example() {
    int a = 10;
    char b = 'x';
    double c = 3.14;
}

A 12 bytes

B 24 bytes

C 16 bytes

D 8 bytes

💡 Hint

Consider data type sizes and alignment on a 32-bit system.

On a 32-bit system, int is 4 bytes, char is 1 byte but padded to 4 bytes for alignment, double is 8 bytes. Total stack usage is 4 (int) + 4 (char padded) + 8 (double) = 16 bytes.