Why dynamic memory is needed - Quick Recap

Recall & Review

beginner

What is dynamic memory in C?

Dynamic memory is memory allocated during program execution using functions like malloc(), calloc(), and realloc(). It allows flexible use of memory based on program needs.

beginner

Why can't we always use static memory allocation?

Static memory allocation fixes memory size at compile time, which can waste memory or limit program flexibility if the exact size is unknown or changes during runtime.

beginner

How does dynamic memory help with unknown data sizes?

Dynamic memory lets programs allocate exactly the amount of memory needed at runtime, which is useful when data size is unknown or changes, like reading user input or files.

beginner

What happens if you don't free dynamic memory?

If dynamic memory is not freed using free(), it causes memory leaks, which waste memory and can slow down or crash programs over time.

beginner

Give a real-life example where dynamic memory is needed.

Imagine a photo app that loads pictures of different sizes. It can't reserve fixed memory for all photos, so it uses dynamic memory to allocate space as needed for each photo.

Which C function is used to allocate dynamic memory?

A malloc()

B printf()

C scanf()

D main()

malloc() allocates memory dynamically during program execution.

Why is dynamic memory allocation useful?

A It makes programs run faster always

B It fixes memory size at compile time

C It allows memory size to change during runtime

D It removes the need to free memory

Dynamic memory allows programs to allocate memory as needed during runtime.

What is a risk of not freeing dynamic memory?

A Faster execution

B Memory leaks

C More CPU usage

D Syntax errors

Not freeing dynamic memory causes memory leaks, wasting memory.

Static memory allocation is done when?

A During program execution

B After program ends

C Only in dynamic languages

D At compile time

Static memory is allocated at compile time and cannot change during execution.

Which scenario needs dynamic memory?

A User inputs unknown number of values

B Declaring constants

C Printing a fixed message

D Fixed size array known at compile time

When the number of inputs is unknown, dynamic memory lets you allocate space as needed.

Explain why dynamic memory is important in C programming.

Think about programs that don't know how much data they will handle before running.

Describe what can happen if dynamic memory is not properly managed.

Consider what happens if memory is allocated but never given back.

Practice

1. Why do we need dynamic memory allocation in C programs?

easy

A. To allocate memory during program execution when size is unknown

B. To make the program run faster by using fixed memory

C. To avoid using pointers in the program

D. To store only constant values in memory

Solution

1. Step 1: Understand static vs dynamic memory

   Static memory is fixed at compile time, so it cannot change size during execution.

2. Step 2: Identify the need for flexible memory

   Dynamic memory allows programs to request memory as needed during runtime, useful when data size is unknown beforehand.

3. Final Answer:

   To allocate memory during program execution when size is unknown -> Option A

4. Quick Check:

   Dynamic memory = flexible size allocation [OK]

Hint: Dynamic memory = memory decided while program runs [OK]

Common Mistakes:

• Confusing dynamic memory with faster execution
• Thinking dynamic memory avoids pointers
• Believing dynamic memory stores only constants

2. Which of the following is the correct syntax to allocate memory dynamically for 10 integers in C?

easy

A. int *ptr = malloc(10);

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

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

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

Solution

1. Step 1: Recall malloc syntax

   malloc requires the number of bytes to allocate, so multiply count by size of type.

2. Step 2: Check each option

   int *ptr = malloc(10 * sizeof(int)); correctly multiplies 10 by sizeof(int) and assigns to int pointer.

3. Final Answer:

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

4. Quick Check:

   malloc size = count * sizeof(type) [OK]

Hint: Always multiply count by sizeof(type) in malloc [OK]

Common Mistakes:

• Not multiplying by sizeof(int)
• Assigning malloc result to non-pointer
• Allocating too little memory

3. What will be the output of this C code snippet?

int *arr = malloc(3 * sizeof(int));
arr[0] = 5;
arr[1] = 10;
arr[2] = 15;
printf("%d", arr[1]);
free(arr);

medium

A. Runtime error

B. 5

C. 15

D. 10

Solution

1. Step 1: Understand array assignment

   arr[1] is assigned the value 10 in the code.

2. Step 2: Check printf output

   printf prints arr[1], so output is 10.

3. Final Answer:

   10 -> Option D

4. Quick Check:

   arr[1] = 10, so output = 10 [OK]

Hint: Index 1 holds 10, so printf prints 10 [OK]

Common Mistakes:

• Confusing index positions
• Forgetting to multiply by sizeof(int) in malloc
• Assuming free causes error here

4. Identify the error in this code snippet:

int *ptr;
ptr = malloc(5);
ptr[0] = 1;
printf("%d", ptr[0]);
free(ptr);

medium

A. Missing #include <stdlib.h> for malloc

B. ptr is not initialized before use

C. malloc size is too small, should be 5 * sizeof(int)

D. free(ptr) should be called before malloc

Solution

1. Step 1: Check malloc size argument

   malloc(5) allocates 5 bytes, but int usually needs 4 bytes each, so 5 bytes is too small for 5 ints.

2. Step 2: Correct malloc size

   It should be malloc(5 * sizeof(int)) to allocate enough memory.

3. Final Answer:

   malloc size is too small, should be 5 * sizeof(int) -> Option C

4. Quick Check:

   malloc size = count * sizeof(type) [OK]

Hint: Always multiply count by sizeof(type) in malloc [OK]

Common Mistakes:

• Ignoring correct malloc size
• Thinking free must come before malloc
• Assuming ptr is uninitialized error

5. You want to store an unknown number of integers entered by the user until they input -1. Which approach best uses dynamic memory in C?

hard

A. Use malloc initially, then realloc to expand as needed

B. Use malloc once for 10 integers and never resize

C. Use only static variables without pointers

D. Declare a fixed-size array of 100 integers

Solution

1. Step 1: Understand unknown input size

   Since the number of integers is unknown, fixed arrays or single malloc calls are insufficient.

2. Step 2: Use realloc for flexible resizing

   Start with malloc, then use realloc to increase memory as more integers are entered.

3. Final Answer:

   Use malloc initially, then realloc to expand as needed -> Option A

4. Quick Check:

   Unknown size needs realloc for resizing [OK]

Hint: Use realloc to grow memory when size unknown [OK]

Common Mistakes:

• Using fixed arrays for unknown input
• Not resizing memory dynamically
• Avoiding pointers for dynamic data