Why dynamic memory is risky in embedded in Embedded C - Test Your Understanding

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a pointer for dynamic memory allocation.

Embedded C

int* [1];

Drag options to blanks, or click blank then click option'

Aptr

Bint

Carray

Dmalloc

Attempts:

3 left

💡 Hint

Common Mistakes

Using a type name instead of a variable name.

The pointer ptr is used to hold the address of dynamically allocated memory.

2fill in blank

medium

Complete the code to allocate memory dynamically for 10 integers.

Embedded C

ptr = (int*) [1](10 * sizeof(int));

Drag options to blanks, or click blank then click option'

Afree

Bmalloc

Csizeof

Dcalloc

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'free' instead of 'malloc'.

malloc allocates a block of memory of the given size.

3fill in blank

hard

Fix the error in the code to properly free the allocated memory.

Embedded C

if (ptr != NULL) {
    [1](ptr);
}

Drag options to blanks, or click blank then click option'

Amalloc

Bcalloc

Cfree

Drealloc

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'malloc' or 'calloc' instead of 'free'.

free releases the memory previously allocated by malloc.

4fill in blank

hard

Fill both blanks to check if memory allocation failed and handle it.

Embedded C

ptr = (int*) malloc(sizeof(int) * 5);
if (ptr [1] NULL) {
    [2]("Allocation failed!\n");
}

Drag options to blanks, or click blank then click option'

A==

Bprintf

C!=

Dscanf

Attempts:

3 left

💡 Hint

Common Mistakes

Using '!=' instead of '==' in the condition.

Using 'scanf' instead of 'printf'.

We check if ptr is equal to NULL to detect failure, then print a message.

5fill in blank

hard

Fill all three blanks to check if memory allocation failed, print an error if it did, and initialize the array otherwise.

Embedded C

int* ptr = (int*) malloc(sizeof(int) * 10);
if (ptr [1] NULL) {
    [2]("Memory allocation failed!\n");
} else {
    for (int i = 0; i [3] 10; i++) {
        ptr[i] = i * i;
    }
}

Drag options to blanks, or click blank then click option'

A==

Bprintf

C<

D!=

Attempts:

3 left

💡 Hint

Common Mistakes

Using '!=' instead of '==' for failure check.

Using '>' instead of '<' in loop condition.

We check if ptr == NULL to detect allocation failure, print an error if failed, and loop to fill ptr[i] = i * i for i < 10 if successful.

Practice

1. Why is dynamic memory allocation considered risky in embedded systems?

easy

A. Because dynamic memory allocation never fails in embedded systems

B. Because dynamic memory allocation is faster than static allocation

C. Because embedded systems always have unlimited memory

D. Because embedded systems have limited memory and dynamic allocation can cause fragmentation

Solution

1. Step 1: Understand embedded system memory constraints

   Embedded systems usually have very limited memory compared to general computers.

2. Step 2: Analyze dynamic memory risks

   Dynamic memory allocation can cause fragmentation and unpredictable failures in limited memory environments.

3. Final Answer:

   Because embedded systems have limited memory and dynamic allocation can cause fragmentation -> Option D

4. Quick Check:

   Limited memory + fragmentation = risk [OK]

Hint: Remember embedded memory is small; dynamic use risks fragmentation [OK]

Common Mistakes:

• Thinking dynamic memory is always faster
• Assuming embedded systems have unlimited memory
• Ignoring fragmentation problems

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

easy

A. int *ptr = malloc(sizeof(int) * 10);

B. int ptr = malloc(10);

C. int *ptr = malloc(10);

D. int *ptr = malloc(sizeof(int));

Solution

1. Step 1: Understand malloc usage

   malloc requires the size in bytes; to allocate 10 integers, multiply sizeof(int) by 10.

2. Step 2: Check pointer type and size

   int *ptr = malloc(sizeof(int) * 10); correctly assigns the pointer and allocates memory for 10 integers.

3. Final Answer:

   int *ptr = malloc(sizeof(int) * 10); -> Option A

4. Quick Check:

   Correct pointer and size usage = int *ptr = malloc(sizeof(int) * 10); [OK]

Hint: Use sizeof(type) * count for malloc size [OK]

Common Mistakes:

• Not multiplying by sizeof(int)
• Assigning malloc to non-pointer variable
• Allocating wrong size

3. What will happen if you forget to free dynamically allocated memory in an embedded system?

medium

A. Memory leak occurs, reducing available memory over time

B. The system will automatically free memory when the program ends

C. The program will run faster because memory is reused automatically

D. The allocated memory will be freed immediately after allocation

Solution

1. Step 1: Understand what happens when memory is not freed

   Not freeing allocated memory causes memory to remain occupied, leading to leaks.

2. Step 2: Analyze embedded system impact

   In embedded systems with limited memory, leaks reduce available memory and can cause failures.

3. Final Answer:

   Memory leak occurs, reducing available memory over time -> Option A

4. Quick Check:

   Unfreed memory = leak = Memory leak occurs, reducing available memory over time [OK]

Hint: Always free memory to avoid leaks [OK]

Common Mistakes:

• Assuming memory frees automatically
• Thinking leaks improve speed
• Confusing allocation and freeing

4. Given the code snippet:

char *buffer = malloc(50);
// ... use buffer
// missing free(buffer);

What is the main problem here?

medium

A. Buffer overflow risk

B. Memory leak due to missing free

C. Syntax error in malloc call

D. Buffer is freed twice

Solution

1. Step 1: Check malloc usage

   malloc(50) allocates 50 bytes correctly; no syntax error.

2. Step 2: Identify missing free

   Code does not call free(buffer), causing a memory leak.

3. Final Answer:

   Memory leak due to missing free -> Option B

4. Quick Check:

   Missing free = leak = Memory leak due to missing free [OK]

Hint: Always pair malloc with free [OK]

Common Mistakes:

• Confusing missing free with buffer overflow
• Thinking malloc syntax is wrong
• Assuming double free without evidence

5. In an embedded system with 1KB RAM, which approach best avoids risks of dynamic memory allocation?

hard

A. Ignore allocation failures and continue running

B. Allocate large dynamic buffers frequently and free them later

C. Use static memory allocation and fixed-size buffers

D. Use dynamic allocation without freeing memory

Solution

1. Step 1: Consider memory limits

   With only 1KB RAM, dynamic allocation risks fragmentation and failure.

2. Step 2: Evaluate safe memory management

   Static allocation with fixed buffers avoids fragmentation and unpredictable failures.

3. Final Answer:

   Use static memory allocation and fixed-size buffers -> Option C

4. Quick Check:

   Static allocation = safer in limited RAM [OK]

Hint: Prefer static allocation in tight memory systems [OK]

Common Mistakes:

• Thinking dynamic allocation is always safe
• Ignoring allocation failure checks
• Assuming freeing memory fixes fragmentation