Why dynamic memory is needed in C++ - See It in Action

Why dynamic memory is needed

📖 Scenario: Imagine you are creating a program that stores the names of students in a class. Sometimes the class size changes, and you don't know the number of students before running the program.

🎯 Goal: You will learn why dynamic memory is needed by creating a program that stores student names using dynamic memory allocation in C++.

📋 What You'll Learn

Create a pointer to store student names dynamically

Use new to allocate memory for student names

Use a variable to store the number of students

Use a loop to input student names

Print all student names stored in dynamic memory

💡 Why This Matters

🌍 Real World

Dynamic memory is used in programs where the amount of data changes, like storing user input, files, or network data.

💼 Career

Understanding dynamic memory is important for software developers working with C++ to manage resources efficiently and avoid crashes.

1

Create a variable for the number of students

Create an int variable called numStudents and set it to 3.

C++

// Create an int variable called numStudents and set it to 3
// Your code here

Hint

Use int numStudents = 3; to store the number of students.

2

Create a dynamic array for student names

Create a pointer to string called students and use new to allocate an array of numStudents strings.

C++

int numStudents = 3;
// Create a pointer to string called students and allocate memory for numStudents strings
// Your code here

Hint

Use std::string* students = new std::string[numStudents]; to allocate dynamic memory.

3

Input student names using a loop

Use a for loop with variable i from 0 to numStudents - 1 to input student names into students[i].

C++

int numStudents = 3;
std::string* students = new std::string[numStudents];
// Use a for loop to input student names into students array
// Your code here

Hint

Use for (int i = 0; i < numStudents; i++) and std::getline(std::cin, students[i]); to read names.

4

Print student names and free memory

Use a for loop with variable i from 0 to numStudents - 1 to print each student name from students[i]. Then use delete[] students; to free the dynamic memory.

C++

int numStudents = 3;
std::string* students = new std::string[numStudents];
for (int i = 0; i < numStudents; i++) {
    std::cout << "Enter name for student " << i + 1 << ": ";
    std::getline(std::cin, students[i]);
}
// Print all student names and free the dynamic memory
// Your code here

Hint

Use a loop to print names and delete[] students; to free memory.

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