Dynamic memory allocation (heap) in Compiler Design - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Understanding Heap Memory Allocation

Which of the following best describes the heap in dynamic memory allocation?

A A large pool of memory used for dynamic allocation during program execution.

B A special register in the CPU that manages memory addresses.

C A memory region where variables are stored temporarily during program compilation.

D A fixed-size memory area used for storing local variables during function calls.

💡 Hint

Think about where memory is allocated when you use commands like malloc or new.

The heap is a large pool of memory used for dynamic allocation at runtime. It allows programs to request and release memory as needed, unlike the stack which is fixed and used for function calls.

📋 Factual

intermediate

Heap Allocation Characteristics

Which statement about heap memory allocation is TRUE?

A Memory allocated on the heap is automatically freed when a function ends.

B Heap memory size is fixed and cannot grow during program execution.

C Heap memory is faster to allocate and deallocate than stack memory.

D Heap memory allocation requires explicit management by the programmer.

💡 Hint

Consider who is responsible for freeing memory allocated on the heap.

Heap memory must be explicitly managed by the programmer, meaning they must allocate and free it manually. Unlike stack memory, it is not automatically freed when a function ends.

🚀 Application

advanced

Identifying Heap Allocation in Code

Given the following pseudo-code, which line is responsible for allocating memory on the heap?

1: int x = 10
2: int* p = allocate(4)
3: p[0] = x
4: free(p)

A Line 2

B Line 3

C Line 1

D Line 4

💡 Hint

Look for the command that requests memory dynamically.

Line 2 uses an allocate function to request 4 bytes of memory on the heap. This is dynamic allocation. Line 4 frees that memory.

🔍 Analysis

advanced

Consequences of Improper Heap Management

What is the most likely consequence if a program allocates memory on the heap but never frees it?

A The program will run faster due to cached memory.

B The program will crash immediately after allocation.

C The program will gradually consume more memory, possibly causing a memory leak.

D The program will automatically free the memory when the function ends.

💡 Hint

Think about what happens if memory is never returned to the system.

If memory allocated on the heap is not freed, it remains reserved and unavailable for other uses. Over time, this causes the program to consume more memory, leading to a memory leak.

❓ Reasoning

expert

Heap Allocation and Fragmentation

Why can frequent allocation and deallocation of different sized blocks on the heap lead to fragmentation?

A Because the CPU cache cannot store heap addresses efficiently.

B Because small free blocks get scattered between allocated blocks, making it hard to find large contiguous space.

C Because the stack grows into the heap causing overlap.

D Because the heap merges all free blocks into one large block automatically.

💡 Hint

Consider how free spaces are arranged after many allocations and frees.

Fragmentation happens when free memory blocks are scattered in small pieces between allocated blocks. This makes it difficult to allocate large contiguous blocks even if total free memory is sufficient.

Practice

1. What is the main purpose of dynamic memory allocation in programming?

easy

A. To store program instructions permanently

B. To allocate memory only at the start of the program

C. To allocate memory during program execution as needed

D. To speed up the compilation process

Solution

1. Step 1: Understand dynamic memory allocation

   Dynamic memory allocation allows a program to request memory while it is running, not just before it starts.

2. Step 2: Compare with static allocation

   Static allocation reserves memory only at compile time or program start, unlike dynamic allocation which is flexible during execution.

3. Final Answer:

   To allocate memory during program execution as needed -> Option C

4. Quick Check:

   Dynamic allocation = allocate memory at runtime [OK]

Hint: Dynamic means memory allocated while program runs [OK]

Common Mistakes:

• Confusing dynamic with static allocation
• Thinking memory is allocated only once at start
• Assuming dynamic allocation speeds up compilation

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

easy

A. int ptr = new int;

B. int ptr = malloc(int);

C. int *ptr = allocate(int);

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

Solution

1. Step 1: Recall C dynamic memory syntax

   In C, malloc is used with the size in bytes, e.g., malloc(sizeof(int)).

2. Step 2: Check each option

   int *ptr = malloc(sizeof(int)); uses correct syntax with pointer and malloc. Others use incorrect functions or syntax.

3. Final Answer:

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

4. Quick Check:

   C malloc syntax = int *ptr = malloc(sizeof(type)) [OK]

Hint: malloc needs pointer and size in bytes [OK]

Common Mistakes:

• Using malloc without sizeof
• Assigning malloc result to non-pointer
• Using non-C functions like allocate or new

3. Consider this C code snippet:

int *p = malloc(3 * sizeof(int));
p[0] = 10;
p[1] = 20;
p[2] = 30;
printf("%d", p[1]);

What will be the output?

medium

A. 20

B. 10

C. 30

D. Runtime error

Solution

1. Step 1: Understand memory allocation and indexing

   Memory for 3 integers is allocated. Values assigned are p[0]=10, p[1]=20, p[2]=30.

2. Step 2: Identify printed value

   The printf prints p[1], which is 20.

3. Final Answer:

   20 -> Option A

4. Quick Check:

   p[1] = 20 printed [OK]

Hint: Array index 1 holds second value assigned [OK]

Common Mistakes:

• Confusing p[0] with p[1]
• Expecting runtime error without free()
• Misunderstanding pointer indexing

4. Identify the error in this C code snippet:

int *ptr;
*ptr = 5;
ptr = malloc(sizeof(int));

medium

A. Memory is allocated after dereferencing pointer

B. malloc syntax is incorrect

C. Pointer is not declared

D. No error, code is correct

Solution

1. Step 1: Analyze pointer usage order

   The code dereferences ptr before allocating memory with malloc.

2. Step 2: Understand consequences

   Dereferencing an uninitialized pointer causes undefined behavior or crash.

3. Final Answer:

   Memory is allocated after dereferencing pointer -> Option A

4. Quick Check:

   Dereference before malloc = error [OK]

Hint: Always malloc before using pointer dereference [OK]

Common Mistakes:

• Ignoring pointer initialization order
• Thinking malloc syntax is wrong
• Assuming no error without free()

5. You want to store a list of names where the number of names is unknown at compile time. Which approach best uses dynamic memory allocation?

hard

A. Allocate a fixed-size array large enough for all names

B. Use malloc to allocate memory for each name as it is added

C. Declare all names as global variables

D. Use static arrays inside functions

Solution

1. Step 1: Understand problem requirements

   The number of names is unknown, so fixed-size arrays may waste memory or be insufficient.

2. Step 2: Choose dynamic allocation strategy

   Allocating memory for each name as it is added allows flexible, efficient use of heap memory.

3. Final Answer:

   Use malloc to allocate memory for each name as it is added -> Option B

4. Quick Check:

   Unknown size = allocate dynamically per item [OK]

Hint: Allocate memory as data arrives, not fixed size [OK]

Common Mistakes:

• Using fixed arrays wasting memory
• Declaring globals wastes flexibility
• Using static arrays limits size