Dynamic memory allocation (heap) in Compiler Design - Mini Project: Build & Apply

Understanding Dynamic Memory Allocation (Heap)

📖 Scenario: Imagine you are designing a simple program that needs to store information about books in a library. The number of books is not fixed and can change while the program runs. To handle this, you will learn how dynamic memory allocation works using the heap.

🎯 Goal: You will build a conceptual model of dynamic memory allocation on the heap by creating a list of book titles, setting a limit for maximum books, adding new books dynamically, and finally marking the end of the list.

📋 What You'll Learn

Create a list called books with three initial book titles exactly: '1984', 'Brave New World', and 'Fahrenheit 451'.

Create a variable called max_books and set it to 5 to represent the maximum number of books allowed.

Add two more book titles 'The Handmaid's Tale' and 'The Road' to the books list dynamically.

Add a special string 'END' at the end of the books list to mark the end of allocated memory.

💡 Why This Matters

🌍 Real World

Dynamic memory allocation is used in programs where the amount of data changes during execution, such as managing lists of users, files, or game objects.

💼 Career

Understanding heap allocation is essential for software developers, especially those working with low-level languages or performance-critical applications.

1

Create the initial list of books

Create a list called books with these exact book titles: '1984', 'Brave New World', and 'Fahrenheit 451'.

Compiler Design

# Create the initial list of books
# Your code here

Hint

Use square brackets [] to create a list and separate items with commas.

2

Set the maximum number of books allowed

Create a variable called max_books and set it to the number 5 to represent the maximum books allowed in memory.

Compiler Design

books = ['1984', 'Brave New World', 'Fahrenheit 451']
# Set max_books to 5
# Your code here

Hint

Just assign the number 5 to the variable max_books.

3

Add two more books dynamically

Add the book titles 'The Handmaid's Tale' and 'The Road' to the books list using the append() method.

Compiler Design

books = ['1984', 'Brave New World', 'Fahrenheit 451']
max_books = 5
# Add two more books dynamically
# Your code here

Hint

Use books.append('Book Title') to add each new book.

4

Mark the end of the allocated memory

Add the string 'END' at the end of the books list to mark the end of allocated memory using the append() method.

Compiler Design

books = ['1984', 'Brave New World', 'Fahrenheit 451']
max_books = 5
books.append('The Handmaid\'s Tale')
books.append('The Road')
# Mark the end of allocated memory
# Your code here

Hint

Use append() again to add the 'END' marker.

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