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.

Practice

1. In embedded C, where are local variables inside functions typically stored?

easy

A. On the stack

B. On the heap

C. In flash memory

D. In CPU registers only

Solution

1. Step 1: Understand local variable storage

   Local variables inside functions are temporary and exist only during function execution.

2. Step 2: Identify stack usage in embedded C

   The stack is used to store temporary data like local variables and return addresses.

3. Final Answer:

   On the stack -> Option A

4. Quick Check:

   Local variables = stack [OK]

Hint: Local variables go on stack, dynamic memory on heap [OK]

Common Mistakes:

• Confusing heap with stack for local variables
• Thinking local variables are stored in flash
• Assuming all variables are in CPU registers

2. Which of the following is the correct way to allocate memory dynamically in embedded C?

easy

A. int p = malloc(sizeof(int));

B. int *p = sizeof(int);

C. int *p = malloc(sizeof(int));

D. malloc(int p);

Solution

1. Step 1: Recall malloc syntax

   malloc returns a pointer to allocated memory, so pointer variable is needed.

2. Step 2: Check each option

   int *p = malloc(sizeof(int)); correctly assigns malloc's return to an int pointer. Others misuse types or syntax.

3. Final Answer:

   int *p = malloc(sizeof(int)); -> Option C

4. Quick Check:

   malloc returns pointer, assign to pointer [OK]

Hint: malloc returns pointer, assign to pointer variable [OK]

Common Mistakes:

• Assigning malloc result to non-pointer variable
• Using sizeof without malloc
• Incorrect function call syntax

3. What will happen if you declare a large array inside a function in embedded C on a system with limited stack size?

medium

A. Stack overflow may occur causing a crash

B. Heap memory will be used automatically

C. The array will be stored in flash memory

D. The compiler will convert it to a global variable

Solution

1. Step 1: Understand stack size limits

   Stack size is limited in embedded systems; large local arrays consume stack space.

2. Step 2: Consequence of large stack allocation

   Allocating large arrays locally can exceed stack size, causing overflow and crash.

3. Final Answer:

   Stack overflow may occur causing a crash -> Option A

4. Quick Check:

   Large local arrays risk stack overflow [OK]

Hint: Large local arrays risk stack overflow in embedded [OK]

Common Mistakes:

• Assuming heap is used automatically
• Thinking large arrays go to flash
• Believing compiler auto-converts locals to globals

4. Consider this code snippet in embedded C:

void func() {
  int *p = malloc(10 * sizeof(int));
  // ... use p ...
  // missing free(p);
}

What is the main problem here?

medium

A. Pointer p is not initialized

B. Stack overflow due to large local array

C. Syntax error in malloc usage

D. Memory leak because allocated heap memory is not freed

Solution

1. Step 1: Analyze malloc usage

   Memory is allocated on the heap with malloc but never freed.

2. Step 2: Identify consequences of missing free

   Not freeing heap memory causes memory leak, wasting limited embedded memory.

3. Final Answer:

   Memory leak because allocated heap memory is not freed -> Option D

4. Quick Check:

   Missing free causes memory leak [OK]

Hint: Always free malloc memory to avoid leaks [OK]

Common Mistakes:

• Confusing stack overflow with memory leak
• Thinking malloc syntax is wrong
• Assuming pointer is uninitialized

5. In an embedded system with 2KB stack and 4KB heap, which approach is best to safely allocate a 1KB buffer for temporary data?

hard

A. Declare a local array of 1KB inside a function

B. Use malloc to allocate 1KB on the heap and free after use

C. Declare a global 1KB array to avoid stack and heap

D. Use a static local array inside the function

Solution

1. Step 1: Evaluate stack usage for large buffer

   1KB local array uses half the stack, risking overflow in embedded systems.

2. Step 2: Consider heap allocation safety

   Allocating 1KB on heap with malloc is safer; heap is larger and managed manually.

3. Step 3: Compare global and static arrays

   Global/static arrays use fixed memory but reduce flexibility and increase RAM usage always.

4. Final Answer:

   Use malloc to allocate 1KB on the heap and free after use -> Option B

5. Quick Check:

   Heap allocation safer for large temporary buffers [OK]

Hint: Use heap malloc for large temporary buffers in embedded [OK]

Common Mistakes:

• Using large local arrays risking stack overflow
• Ignoring freeing heap memory
• Assuming global arrays are always best