Why dynamic memory is needed - Challenge Your Understanding

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why use dynamic memory allocation in C?

Which of the following best explains why dynamic memory allocation is needed in C programming?

A To improve the speed of the program by using static memory only.

B To allocate memory at compile time for fixed-size variables.

C To avoid using pointers and arrays in the program.

D To allocate memory during program execution when the size is not known beforehand.

💡 Hint

Think about when the program needs memory but does not know how much it will need before running.

Dynamic memory allocation allows a program to request memory while it is running, which is useful when the amount of memory needed cannot be determined before the program starts.

❓ Predict Output

intermediate

Output of dynamic memory allocation example

What is the output of the following C code?

C

#include <stdio.h>
#include <stdlib.h>

int main() {
    int *ptr = (int *)malloc(3 * sizeof(int));
    if (ptr == NULL) {
        printf("Memory allocation failed\n");
        return 1;
    }
    ptr[0] = 10;
    ptr[1] = 20;
    ptr[2] = 30;
    printf("%d %d %d\n", ptr[0], ptr[1], ptr[2]);
    free(ptr);
    return 0;
}

A 10 20 30

B Memory allocation failed

C 0 0 0

D Compilation error

💡 Hint

Check if memory allocation was successful and values assigned before printing.

The program allocates memory for 3 integers, assigns values, and prints them. Since allocation succeeds, it prints '10 20 30'.

❓ Predict Output

advanced

What happens if malloc fails?

What will be the output of this C program if malloc fails to allocate memory?

C

#include <stdio.h>
#include <stdlib.h>

int main() {
    int *ptr = (int *)malloc((size_t)1000000000000 * sizeof(int));
    if (ptr == NULL) {
        printf("Allocation failed\n");
    } else {
        printf("Allocation succeeded\n");
        free(ptr);
    }
    return 0;
}

A Allocation succeeded

B Allocation failed

C Compilation error due to large size

D Program crashes without output

💡 Hint

Consider what happens when malloc cannot find enough memory.

If malloc cannot allocate the requested memory, it returns NULL, so the program prints 'Allocation failed'.

🧠 Conceptual

advanced

Why is dynamic memory preferred over static for large data?

Why is dynamic memory allocation preferred over static allocation for large or variable-sized data in C?

A Static memory is faster but limited in size and fixed at compile time.

B Dynamic memory is slower and fixed in size at compile time.

C Dynamic memory allocation does not require freeing memory after use.

D Static memory can only store integers, dynamic memory can store any data type.

💡 Hint

Think about when the program size or data size is not known before running.

Static memory is allocated at compile time and cannot change size, so dynamic memory is used for large or variable data sizes during runtime.

❓ Predict Output

expert

Value of pointer after free() call

What is the value of ptr after calling free(ptr); in this program?

C

#include <stdio.h>
#include <stdlib.h>

int main() {
    int *ptr = malloc(sizeof(int));
    *ptr = 42;
    free(ptr);
    printf("%p\n", (void *)ptr);
    return 0;
}

A NULL

B 0

C Address of the freed memory block (non-NULL pointer)

D Compilation error because ptr is used after free

💡 Hint

Does free() change the pointer variable itself?

Calling free() releases the memory but does not change the pointer value. The pointer still holds the address but it is now a dangling pointer.

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