Why dynamic memory is needed in C++ - Challenge Your Understanding

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why use dynamic memory in C++?

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

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

B To allocate memory at compile time for fixed size arrays.

C To store constants and literals in the program.

D To improve the speed of the program by using static memory.

💡 Hint

Think about when you don't know how much memory you need before the program runs.

Dynamic memory allows programs to request memory while running, which is useful when the amount of data is not fixed or known in advance.

❓ Predict Output

intermediate

Output of dynamic memory allocation example

What is the output of this C++ code?

C++

#include <iostream>
int main() {
    int n = 3;
    int* arr = new int[n];
    for(int i = 0; i < n; i++) {
        arr[i] = i * 2;
    }
    std::cout << arr[2] << std::endl;
    delete[] arr;
    return 0;
}

A 6

B 2

C 4

D 0

💡 Hint

Look at the loop and what values are assigned to each element.

The loop assigns arr[i] = i * 2. For i=2, arr[2] = 2 * 2 = 4.

❓ Predict Output

advanced

What happens if dynamic memory is not freed?

What will happen if you run this C++ code repeatedly without freeing the allocated memory?

C++

#include <iostream>
int main() {
    while(true) {
        int* ptr = new int[1000];
        // no delete[] ptr;
    }
    return 0;
}

A The program will crash or slow down due to memory leak.

B The program will print an error message and stop.

C The program will run forever without any issues.

D The program will free memory automatically after each loop.

💡 Hint

Think about what happens when memory is allocated but never released.

Not freeing dynamic memory causes a memory leak, which can slow down or crash the program as memory runs out.

🧠 Conceptual

advanced

Why can't static arrays always replace dynamic memory?

Why are static arrays not always enough, making dynamic memory necessary?

A Static arrays use more memory than dynamic memory.

B Static arrays are slower than dynamic memory.

C Static arrays can only store integers, dynamic memory can store any type.

D Static arrays have fixed size known at compile time, dynamic memory allows flexible size at runtime.

💡 Hint

Think about when you need to decide the size of an array while the program runs.

Static arrays require size known before running the program. Dynamic memory allows allocating memory based on runtime needs.

🧠 Conceptual

expert

When is dynamic memory allocation most beneficial?

In which scenario is dynamic memory allocation most beneficial?

A When the program does not require any memory allocation.

B When the program needs to handle data whose size changes during execution.

C When the program only uses small amounts of memory once.

D When the program needs to store a fixed number of elements known at compile time.

💡 Hint

Think about programs that grow or shrink data while running.

Dynamic memory is useful when data size is not fixed and can change during program execution.

Practice

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

easy

A. To write code without any variables

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

C. To avoid using any memory at all

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

Solution

1. Step 1: Understand memory allocation timing

   Static memory is fixed before running, but dynamic memory is allocated while the program runs.

2. Step 2: Recognize the need for unknown sizes

   When the amount of data is not known before running, dynamic memory allows flexible allocation.

3. Final Answer:

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

4. Quick Check:

   Dynamic memory = flexible size allocation [OK]

Hint: Dynamic memory = memory decided during program run [OK]

Common Mistakes:

• Thinking dynamic memory is for speed only
• Confusing dynamic with static memory
• Believing dynamic memory avoids variables

2. Which of the following is the correct syntax to allocate an integer dynamically in C++?

easy

A. int *p = new int;

B. int p = new int;

C. int *p = int new;

D. new int = int *p;

Solution

1. Step 1: Recall dynamic allocation syntax

   In C++, dynamic memory for an int is allocated using 'new int' and assigned to an int pointer.

2. Step 2: Check pointer declaration

   The pointer must be declared as 'int *p' to hold the address of the allocated int.

3. Final Answer:

   int *p = new int; -> Option A

4. Quick Check:

   Pointer = new type; correct syntax [OK]

Hint: Use 'int *p = new int;' for dynamic int allocation [OK]

Common Mistakes:

• Missing pointer * in declaration
• Wrong order of new and type
• Assigning new int to non-pointer variable

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

int *arr = new int[3];
arr[0] = 10;
arr[1] = 20;
arr[2] = 30;
std::cout << arr[1] << std::endl;
delete[] arr;

medium

A. 10

B. 30

C. Compilation error

D. 20

Solution

1. Step 1: Understand array allocation and assignment

   Dynamic array of size 3 is created, and values 10, 20, 30 are assigned to indices 0, 1, 2 respectively.

2. Step 2: Identify output statement

   The code prints arr[1], which holds the value 20.

3. Final Answer:

   20 -> Option D

4. Quick Check:

   arr[1] = 20 printed [OK]

Hint: Index 1 of array holds 20, so output is 20 [OK]

Common Mistakes:

• Confusing index positions
• Forgetting to use delete[] for arrays
• Assuming compilation error due to dynamic array

4. Identify the error in this C++ code snippet:

int *p;
p = new int(5);
std::cout << *p << std::endl;
// missing delete statement

medium

A. Missing delete to free allocated memory

B. Syntax error in new int(5)

C. Pointer p is not declared

D. Cannot print value using *p

Solution

1. Step 1: Check dynamic allocation correctness

   Pointer p is declared and assigned new int(5), which is correct syntax.

2. Step 2: Identify missing memory management

   Allocated memory is not freed with delete, causing a memory leak.

3. Final Answer:

   Missing delete to free allocated memory -> Option A

4. Quick Check:

   Always delete after new to avoid leaks [OK]

Hint: Always pair new with delete to free memory [OK]

Common Mistakes:

• Ignoring memory leaks
• Thinking new int(5) is wrong syntax
• Assuming pointer must be initialized differently

5. You want to store user input numbers but don't know how many will be entered. Which approach using dynamic memory is best?

hard

A. Use only static variables to store numbers

B. Use a fixed-size array of 100 elements

C. Use a dynamically allocated array and resize it as needed

D. Use a pointer without allocating memory

Solution

1. Step 1: Understand the problem of unknown input size

   Since the number of inputs is unknown, fixed-size arrays may waste memory or be too small.

2. Step 2: Choose flexible memory allocation

   Dynamically allocated arrays can be resized (e.g., by allocating new larger arrays and copying data) to fit input size.

3. Final Answer:

   Use a dynamically allocated array and resize it as needed -> Option C

4. Quick Check:

   Dynamic resizing fits unknown input sizes [OK]

Hint: Resize dynamic array to fit unknown input size [OK]

Common Mistakes:

• Using fixed arrays that may overflow
• Not allocating memory before use
• Ignoring memory management when resizing