Why dynamic memory is needed - Test Your Understanding

Practice - 5 Tasks

1fill in blank

easy

Complete the code to allocate memory dynamically for an integer.

C

#include <stdlib.h>

int main() {
    int *ptr = (int*)[1](sizeof(int));
    if (ptr == NULL) {
        return 1;
    }
    *ptr = 10;
    free(ptr);
    return 0;
}

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

Amalloc

Bprintf

Csizeof

Dfree

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'sizeof' instead of a memory allocation function.

Forgetting to cast the return value of malloc.

Using 'free' instead of 'malloc' for allocation.

The malloc function allocates memory dynamically. Here, it allocates enough space for one integer.

2fill in blank

medium

Complete the code to allocate memory for an array of 5 integers dynamically.

C

#include <stdlib.h>

int main() {
    int *arr = (int*)malloc([1] * sizeof(int));
    if (arr == NULL) {
        return 1;
    }
    free(arr);
    return 0;
}

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

A10

B0

Csizeof(arr)

D5

Attempts:

3 left

💡 Hint

Common Mistakes

Using the size of the pointer instead of the number of elements.

Allocating zero bytes.

Using an incorrect number for the array size.

We multiply the number of elements (5) by the size of each integer to allocate enough memory for the array.

3fill in blank

hard

Fix the error in the code to properly allocate and free memory for a float variable.

C

#include <stdlib.h>

int main() {
    float *ptr = (float*)[1](sizeof(float));
    if (ptr == NULL) {
        return 1;
    }
    *ptr = 3.14f;
    free(ptr);
    return 0;
}

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

Amalloc

Bfree

Csizeof

Dcalloc

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'free' instead of 'malloc' for allocation.

Confusing 'sizeof' with allocation functions.

Using 'calloc' without initializing properly.

The malloc function is used to allocate memory. Using free here is incorrect because it deallocates memory.

4fill in blank

hard

Fill both blanks to allocate memory for 10 doubles and check if allocation was successful.

C

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

int main() {
    double *data = (double*)[1](10 * sizeof(double));
    if (data [2] NULL) {
        printf("Allocation failed\n");
        return 1;
    }
    free(data);
    return 0;
}

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

Amalloc

B==

C!=

Dfree

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'free' instead of 'malloc' for allocation.

Checking if pointer equals NULL instead of not equals.

Using '==' instead of '!=' in the condition.

malloc allocates memory. We check if the pointer is not equal to NULL to confirm successful allocation.

5fill in blank

hard

Fill all three blanks to create a dynamic array of chars, assign a value, and free the memory.

C

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

int main() {
    char *buffer = (char*)[1](20 * sizeof(char));
    if (buffer == NULL) {
        return 1;
    }
    buffer[0] = [2];
    printf("First char: %c\n", buffer[0]);
    [3](buffer);
    return 0;
}

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

Amalloc

B'A'

Cfree

Dcalloc

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'calloc' instead of 'malloc' without explanation.

Assigning a string instead of a character.

Forgetting to free the allocated memory.

We use malloc to allocate memory, assign the character 'A' to the first element, and then free the memory with free.

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