Memory allocation and deallocation in C++ - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of dynamic memory allocation with pointers

What is the output of the following C++ code?

C++

#include <iostream>
int main() {
    int* p = new int(10);
    std::cout << *p << std::endl;
    delete p;
    return 0;
}

A 0

B Compilation error

C Runtime error

D 10

💡 Hint

Remember that new allocates memory and initializes the value.

The pointer p points to a dynamically allocated int initialized to 10. Dereferencing *p prints 10.

❓ Predict Output

intermediate

Output after deleting and accessing pointer

What happens when you run this C++ code?

C++

#include <iostream>
int main() {
    int* p = new int(5);
    delete p;
    std::cout << *p << std::endl;
    return 0;
}

A Undefined behavior (may print garbage or crash)

B 5

C Compilation error

D 0

💡 Hint

Accessing memory after delete is unsafe.

After delete, the pointer p is dangling. Dereferencing it causes undefined behavior, which may print garbage or crash.

🧠 Conceptual

advanced

Correct use of delete[] for arrays

Which option correctly deallocates the dynamically allocated array in C++?

A int* arr = new int[5]; delete arr;

B int* arr = new int[5]; free(arr);

C int* arr = new int[5]; delete[] arr;

D int* arr = new int[5]; delete arr[0];

💡 Hint

Arrays allocated with new[] must be deallocated with delete[].

Using delete[] properly frees the entire array. Using delete without [] causes undefined behavior. free() is for malloc, not new.

❓ Predict Output

advanced

Output of double delete error

What error or output occurs when running this code?

C++

#include <iostream>
int main() {
    int* p = new int(7);
    delete p;
    delete p;
    std::cout << "Done" << std::endl;
    return 0;
}

A Runtime error (double free or corruption)

B 7

C Compilation error

D Done

💡 Hint

Deleting the same pointer twice causes a runtime error.

Double deleting a pointer causes undefined behavior, often a runtime error like double free or corruption.

🧠 Conceptual

expert

Memory leak detection in C++ code

Which option describes the memory leak in the following code snippet?

C++

void foo() {
    int* p = new int[10];
    p = new int[20];
    delete[] p;
}

A No memory leak; all allocated memory is freed.

B Memory leak because the first allocated array is lost without delete.

C Memory leak because delete[] is used incorrectly.

D Memory leak because p is deleted twice.

💡 Hint

Reassigning pointer without deleting old memory causes leak.

The first allocated array is overwritten by p = new int[20]; without deleting it first, causing a memory leak.

Practice

1. What does the new operator do in C++?

easy

A. Allocates memory on the heap for a variable or object

B. Deletes a variable from memory

C. Allocates memory on the stack

D. Copies data from one variable to another

Solution

1. Step 1: Understand the role of new

   The new operator allocates memory dynamically on the heap during program execution.

2. Step 2: Differentiate from other memory actions

   It does not delete memory or allocate on the stack; it only reserves space on the heap.

3. Final Answer:

   Allocates memory on the heap for a variable or object -> Option A

4. Quick Check:

   new = allocate heap memory [OK]

Hint: Remember: new = allocate memory on heap [OK]

Common Mistakes:

• Confusing new with delete
• Thinking new allocates on stack
• Assuming new copies data

2. Which of the following is the correct syntax to deallocate memory allocated with new for a single integer variable?

easy

A. delete[] ptr;

B. free(ptr);

C. delete ptr;

D. ptr = nullptr;

Solution

1. Step 1: Identify correct deallocation for single object

   Memory allocated with new for a single variable must be freed with delete, not delete[].

2. Step 2: Exclude incorrect options

   free() is for C-style malloc, and setting pointer to nullptr does not free memory.

3. Final Answer:

   delete ptr; -> Option C

4. Quick Check:

   Single object deallocation = delete [OK]

Hint: Use delete for single object, delete[] for arrays [OK]

Common Mistakes:

• Using delete[] for single variable
• Using free() instead of delete
• Only setting pointer to nullptr without delete

3. What is the output of the following code?

int* ptr = new int(10);
std::cout << *ptr << std::endl;
delete ptr;

medium

A. 0

B. 10

C. Garbage value

D. Compilation error

Solution

1. Step 1: Analyze memory allocation and initialization

   The pointer ptr points to a new integer initialized with 10.

2. Step 2: Understand output before deletion

   Dereferencing *ptr prints 10 before memory is deleted.

3. Final Answer:

   10 -> Option B

4. Quick Check:

   Dereference new int(10) = 10 [OK]

Hint: Dereference pointer before delete to see value [OK]

Common Mistakes:

• Assuming output is 0 or garbage
• Thinking delete affects output before cout
• Confusing syntax causing compile error

4. Identify the error in the following code snippet:

int* arr = new int[5];
delete arr;

medium

A. Pointer arr is not initialized

B. Memory is not allocated properly

C. No error, code is correct

D. Should use delete[] instead of delete

Solution

1. Step 1: Check allocation type

   Memory allocated with new[] must be deallocated with delete[].

2. Step 2: Identify mismatch in deallocation

   Using delete instead of delete[] causes undefined behavior.

3. Final Answer:

   Should use delete[] instead of delete -> Option D

4. Quick Check:

   Array deallocation = delete[] [OK]

Hint: Match new[] with delete[] always [OK]

Common Mistakes:

• Using delete for arrays
• Ignoring pointer initialization
• Assuming no error in mismatched delete

5. You want to allocate memory for an array of 10 integers and initialize all elements to zero. Which code snippet correctly does this and safely deallocates the memory?

hard

A. int* arr = new int[10](); delete[] arr;

B. int* arr = new int[10]; delete arr;

C. int* arr = (int*)malloc(10 * sizeof(int)); delete[] arr;

D. int* arr = new int(10); delete[] arr;

Solution

1. Step 1: Allocate and initialize array to zero

   Using new int[10]() allocates an array of 10 integers and initializes all to zero.

2. Step 2: Properly deallocate array memory

   Memory allocated with new[] must be freed with delete[] to avoid leaks or undefined behavior.

3. Final Answer:

   int* arr = new int[10](); delete[] arr; -> Option A

4. Quick Check:

   new[] with () + delete[] = safe zero-init array [OK]

Hint: Use new int[size]() and delete[] for arrays [OK]

Common Mistakes:

• Using delete instead of delete[] for arrays
• Mixing malloc/free with new/delete
• Allocating single int instead of array