Dynamic memory allocation (heap) in Compiler Design - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is dynamic memory allocation in the context of the heap?

Dynamic memory allocation is the process where a program requests memory from the heap at runtime, allowing flexible use of memory based on current needs.

beginner

Why is the heap used for dynamic memory allocation instead of the stack?

The heap allows allocating memory of variable size and lifetime, unlike the stack which is limited to fixed-size, short-lived data tied to function calls.

intermediate

What happens if a program requests more heap memory than is available?

The allocation fails, often causing the program to crash or return a null pointer, indicating no memory could be assigned.

intermediate

How does a compiler or runtime system manage heap memory?

It keeps track of allocated and free blocks, often using data structures like free lists, and handles requests to allocate or free memory dynamically.

beginner

What is a memory leak in the context of heap allocation?

A memory leak occurs when allocated heap memory is not freed after use, causing wasted memory and possible program slowdown or crash.

What is the main characteristic of heap memory?

A Memory that cannot be freed during program execution

B Memory allocated automatically for function calls

C Memory that stores only global variables

D Memory allocated at runtime with flexible size and lifetime

Heap memory is allocated dynamically at runtime and can have variable size and lifetime.

Which of the following is a common problem caused by improper heap memory management?

A Memory leak

B Syntax error

C Stack overflow

D Compilation failure

Memory leaks happen when heap memory is allocated but not freed properly.

When does dynamic memory allocation typically occur?

A Only during compilation

B Before program starts

C During program execution

D After program ends

Dynamic memory allocation happens while the program is running, not before or after.

What does the heap manager do?

A Tracks free and used memory blocks on the heap

B Manages CPU registers

C Allocates memory on the stack

D Compiles source code

The heap manager keeps track of which parts of the heap are free or used to handle allocation requests.

Which memory area is best suited for variables with unknown size at compile time?

A Code segment

B Heap

C Stack

D Data segment

The heap allows allocating memory dynamically for variables whose size is not known before running the program.

Explain what dynamic memory allocation on the heap is and why it is important in programming.

Think about how programs handle data when they don't know the size in advance.

Describe common issues that can arise from improper use of heap memory and how they affect a program.

Consider what happens if memory is not freed or if too much memory is requested.

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