new operator in C++ - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does the new operator do in C++?

The new operator allocates memory on the heap for a variable or object and returns a pointer to that memory.

beginner

How do you use new to create an integer on the heap?

You write int* p = new int; which allocates memory for an integer and stores its address in pointer p.

beginner

What must you do after using new to avoid memory leaks?

You must use delete to free the memory allocated by new when it is no longer needed.

intermediate

How do you allocate an array of 5 integers using new?

Use int* arr = new int[5]; to allocate an array of 5 integers on the heap.

intermediate

What is the difference between delete and delete[]?

delete frees memory allocated for a single object, while delete[] frees memory allocated for an array.

What does new return when it successfully allocates memory?

A A pointer to the allocated memory

B The value stored in the memory

C An integer representing the size

D Nothing, it just allocates silently

new returns a pointer to the memory it allocates on the heap.

Which operator should you use to free memory allocated with new[]?

A <code>delete</code>

B <code>free</code>

C <code>delete[]</code>

D <code>release</code>

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

What happens if you forget to use delete after new?

A The program crashes immediately

B The memory is freed automatically

C The pointer becomes null

D Memory leak occurs

Forgetting delete causes memory leaks because allocated memory is not freed.

How do you allocate a single object of a class Car using new?

A Car* c = new Car();

B Car* c = Car();

C Car c = Car();

D Car c = new Car();

You allocate with new and store the pointer: Car* c = new Car();.

Which of the following is true about new?

A It allocates memory on the stack

B It allocates memory on the heap

C It automatically deletes memory

D It returns a reference

new allocates memory on the heap, not the stack.

Explain how the new operator works and why it is important to use delete afterwards.

Think about where memory is allocated and what happens if you don't free it.

Describe the difference between using new for a single object and for an array, including how to free each.

Focus on syntax and matching delete operators.

Practice

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

easy

A. Allocates memory dynamically and returns a pointer to it

B. Deletes a variable from memory

C. Declares a normal variable on the stack

D. Copies data from one variable to another

Solution

1. Step 1: Understand the purpose of new

   The new operator is used to allocate memory on the heap during program execution.

2. Step 2: Identify what new returns

   It returns a pointer to the allocated memory so the program can use it.

3. Final Answer:

   Allocates memory dynamically and returns a pointer to it -> Option A

4. Quick Check:

   new = allocate memory [OK]

Hint: Remember: new creates memory and gives a pointer [OK]

Common Mistakes:

• Confusing new with delete
• Thinking new declares stack variables
• Assuming new copies data

2. Which of the following is the correct syntax to allocate an integer using new?

easy

A. int p = new int;

B. int p = new int();

C. int *p = new int[];

D. int *p = new int;

Solution

1. Step 1: Check pointer declaration

   Using new returns a pointer, so the variable must be a pointer type like int *.

2. Step 2: Verify syntax correctness

   int *p = new int; correctly allocates an int and assigns its address to p.

3. Final Answer:

   int *p = new int; -> Option D

4. Quick Check:

   Pointer = new type [OK]

Hint: new returns pointer, so use pointer variable [OK]

Common Mistakes:

• Declaring variable without pointer
• Using parentheses incorrectly
• Assigning new to non-pointer variable

3. What is the output of this code?

int *arr = new int[3]{10, 20, 30};
std::cout << arr[1] << std::endl;
delete[] arr;

medium

A. 20

B. 10

C. 30

D. Runtime error

Solution

1. Step 1: Understand array allocation with new

   The code creates an array of 3 integers with values 10, 20, 30.

2. Step 2: Access the second element

   Array indexing starts at 0, so arr[1] is the second element, which is 20.

3. Final Answer:

   20 -> Option A

4. Quick Check:

   arr[1] = 20 [OK]

Hint: Remember array index starts at 0 [OK]

Common Mistakes:

• Confusing index 1 with index 0
• Forgetting to use delete[] for arrays
• Expecting runtime error without cause

4. Identify the error in this code snippet:

int *p = new int;
*p = 5;
delete p;
delete p;

medium

A. Incorrect use of new operator

B. Missing initialization of pointer

C. Double deletion of the same pointer

D. No error, code is correct

Solution

1. Step 1: Analyze pointer allocation and deletion

   Pointer p is allocated memory and deleted once correctly.

2. Step 2: Check for repeated delete

   Deleting p a second time causes undefined behavior (double deletion error).

3. Final Answer:

   Double deletion of the same pointer -> Option C

4. Quick Check:

   delete twice = error [OK]

Hint: Delete pointer only once to avoid errors [OK]

Common Mistakes:

• Deleting pointer twice
• Not deleting allocated memory
• Confusing delete and delete[]

5. You want to create a dynamic 2D array of integers with 3 rows and 2 columns using new. Which code correctly allocates and deallocates this array?

hard

A. int *arr = new int[3*2];
// use arr
delete arr;

B. int **arr = new int*[3];
for(int i=0; i<3; i++) arr[i] = new int[2];
// use arr
for(int i=0; i<3; i++) delete[] arr[i];
delete[] arr;

C. int **arr = new int[3][2];
// use arr
delete[] arr;

D. int arr[3][2];
// use arr
// no delete needed

Solution

1. Step 1: Allocate 2D array dynamically

   int **arr = new int*[3]; for(int i=0; i<3; i++) arr[i] = new int[2]; // use arr for(int i=0; i<3; i++) delete[] arr[i]; delete[] arr; correctly creates an array of pointers for rows, then allocates each row as an array of ints.

2. Step 2: Properly deallocate memory

   Each row is deleted with delete[], then the array of pointers is deleted with delete[].

3. Final Answer:

   Uses an array of pointers, allocating each row separately -> Option B

4. Quick Check:

   Nested new and delete[] for 2D arrays [OK]

Hint: Use nested new and delete[] for 2D arrays [OK]

Common Mistakes:

• Using delete instead of delete[] for arrays
• Not deleting all allocated rows
• Trying to allocate 2D array with single new incorrectly