Dynamic memory allocation (heap) in Compiler Design - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to allocate memory dynamically on the heap.

Compiler Design

ptr = malloc([1]);

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

Asizeof(int)

Bint

Cfree

D10

Attempts:

3 left

💡 Hint

Common Mistakes

Passing the type name instead of size.

Using free instead of malloc.

Passing a number without considering the size of the type.

The malloc function requires the size in bytes to allocate memory on the heap. Using sizeof(int) gives the correct size for an integer.

2fill in blank

medium

Complete the code to free the allocated memory correctly.

Compiler Design

free([1]);

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

Asizeof(ptr)

BNULL

Cmalloc

Dptr

Attempts:

3 left

💡 Hint

Common Mistakes

Passing NULL to free.

Passing the size instead of the pointer.

Calling malloc inside free.

The free function releases the memory pointed to by ptr back to the heap.

3fill in blank

hard

Fix the error in the code to allocate memory for an array of 5 integers.

Compiler Design

ptr = malloc(5 [1] sizeof(int));

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

A+

B-

C*

D/

Attempts:

3 left

💡 Hint

Common Mistakes

Using addition instead of multiplication.

Using division or subtraction which are incorrect here.

Forgetting to multiply by the size of the type.

To allocate memory for 5 integers, multiply 5 by the size of an integer using the * operator.

4fill in blank

hard

Fill both blanks to correctly allocate and check memory allocation.

Compiler Design

ptr = malloc([1]);
if (ptr == [2]) {
    // handle error
}

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

Asizeof(int) * 10

BNULL

C0

Dptr

Attempts:

3 left

💡 Hint

Common Mistakes

Not multiplying by the number of elements.

Checking pointer against 0 instead of NULL.

Using the pointer itself in the condition.

Memory is allocated for 10 integers. The pointer is checked against NULL to detect allocation failure.

5fill in blank

hard

Fill all three blanks to correctly allocate and initialize an array of 5 integers to zero.

Compiler Design

ptr = [1]([2], [3]);

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

Acalloc

B5

Csizeof(int)

Dmalloc

Attempts:

3 left

💡 Hint

Common Mistakes

Using malloc, which does not initialize memory.

Confusing the arguments for calloc (num elements vs. total size).

Forgetting sizeof(int) for the element size.

calloc allocates memory for an array of 5 integers and initializes all bytes to zero. It takes the number of elements and the size of each element.

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