delete operator in C++ - Step-by-Step Execution

Concept Flow - delete operator

Allocate memory with new

↓

Use pointer to access memory

↓

Call delete on pointer

↓

Memory freed

↓

Pointer becomes dangling (unsafe)

↓

Set pointer to nullptr to avoid dangling

This flow shows how memory is allocated with new, used, then freed with delete, and why setting pointer to nullptr is important.

Execution Sample

C++

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

Allocates an int with value 10, prints it, deletes the memory, then sets pointer to nullptr.

Execution Table

Step	Action	Pointer p	Memory State	Output
1	Allocate int with value 10	p -> address1	Memory at address1: 10
2	Print value pointed by p	p -> address1	Memory at address1: 10	10
3	Delete memory pointed by p	p -> address1 (dangling)	Memory at address1: freed
4	Set p to nullptr	p = nullptr	No allocated memory

💡 Pointer p set to nullptr to avoid dangling pointer after delete

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4
p	uninitialized	address1	address1	address1 (dangling)	nullptr

Key Moments - 2 Insights

Why do we set the pointer to nullptr after delete?

After delete, the pointer still holds the old address but that memory is freed, making it unsafe (dangling). Setting it to nullptr avoids accidental use, as shown in step 4 of the execution_table.

What happens if we try to access *p after delete but before setting nullptr?

Accessing *p after delete leads to undefined behavior because the memory is freed (step 3). The pointer is dangling and does not point to valid memory.

Visual Quiz - 3 Questions

Look at the execution_table, what is the state of pointer p after step 3?

A p is a dangling pointer pointing to freed memory

B p is nullptr

C p points to valid memory with value 10

D p is uninitialized

💡 Hint

Check the 'Pointer p' and 'Memory State' columns in row for step 3

At which step is the value 10 printed to the output?

A Step 1

B Step 3

C Step 2

D Step 4

💡 Hint

Look at the 'Output' column in the execution_table

If we skip setting p to nullptr after delete, what risk do we face?

A Memory leak

B Dangling pointer usage

C Compilation error

D No risk, safe to use

💡 Hint

Refer to key_moments explanation about pointer safety after delete

Concept Snapshot

delete operator in C++:
- Used to free memory allocated with new
- Syntax: delete pointer;
- After delete, pointer becomes dangling
- Set pointer to nullptr to avoid unsafe access
- Accessing deleted memory causes undefined behavior

Full Transcript

This visual trace shows how the delete operator works in C++. First, memory is allocated with new and pointer p points to it. Then, the value is printed. Next, delete frees the memory but p still points to the old address, making it a dangling pointer. Finally, setting p to nullptr prevents accidental use of freed memory. Key points include always setting pointers to nullptr after delete and never accessing memory after it is deleted.

Practice

1. What is the main purpose of the delete operator in C++?

easy

A. To allocate new memory

B. To free memory allocated with new

C. To copy objects

D. To declare variables

Solution

1. Step 1: Understand memory allocation

   The new operator allocates memory dynamically on the heap.

2. Step 2: Role of delete

   The delete operator frees that allocated memory to avoid leaks.

3. Final Answer:

   To free memory allocated with new -> Option B

4. Quick Check:

   delete frees memory [OK]

Hint: Remember: new allocates, delete frees memory [OK]

Common Mistakes:

• Confusing delete with new
• Using delete to copy objects
• Thinking delete declares variables

2. Which of the following is the correct syntax to delete a dynamically allocated array arr?

easy

A. delete arr;

B. delete array arr;

C. delete arr[];

D. delete[] arr;

Solution

1. Step 1: Identify array deletion syntax

   For arrays allocated with new[], use delete[] to free all elements properly.

2. Step 2: Match correct syntax

   delete[] arr; correctly deletes the entire array.

3. Final Answer:

   delete[] arr; -> Option D

4. Quick Check:

   Use delete[] for arrays [OK]

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

Common Mistakes:

• Using delete instead of delete[] for arrays
• Placing brackets after variable name incorrectly
• Writing delete array arr (invalid syntax)

3. What will be the output of the following code?

int* p = new int(10);
std::cout << *p << std::endl;
delete p;
// std::cout << *p << std::endl; // Uncommenting this line causes what?

medium

A. 10 and then 10 again

B. Compilation error at delete

C. 10 and then undefined behavior

D. Runtime error at new

Solution

1. Step 1: Analyze output before delete

   The pointer p points to an int with value 10, so *p prints 10.

2. Step 2: Effect of delete and accessing pointer

   After delete p;, the memory is freed. Accessing *p after delete causes undefined behavior (may crash or print garbage).

3. Final Answer:

   10 and then undefined behavior -> Option C

4. Quick Check:

   Access after delete = undefined behavior [OK]

Hint: Don't use pointer after delete; it's unsafe [OK]

Common Mistakes:

• Assuming deleted pointer still holds valid data
• Expecting compilation error on delete
• Ignoring undefined behavior risks

4. Identify the error in this code snippet:

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

medium

A. Should use delete[] instead of delete

B. Should use delete without brackets

C. No error, code is correct

D. Should not delete dynamically allocated arrays

Solution

1. Step 1: Check allocation type

   arr is allocated with new int[5], which creates an array.

2. Step 2: Correct deletion method

   Arrays must be deleted with delete[] arr; to properly free all elements.

3. Final Answer:

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

4. Quick Check:

   Array delete needs delete[] [OK]

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

Common Mistakes:

• Using delete for arrays causes undefined behavior
• Thinking delete works for both single and arrays
• Ignoring memory leaks from wrong delete

5. Consider this code:

int** matrix = new int*[3];
for (int i = 0; i < 3; ++i) {
    matrix[i] = new int[4];
}
// Code to delete matrix properly?

Which is the correct way to delete all allocated memory?

hard

A. for (int i = 0; i < 3; ++i) delete[] matrix[i]; delete[] matrix;

B. for (int i = 0; i < 3; ++i) delete matrix[i]; delete[] matrix;

C. delete[] matrix; delete[] matrix[0];

D. delete matrix; delete matrix[0];

Solution

1. Step 1: Understand allocation

   Each matrix[i] is an array allocated with new int[4], so must be deleted with delete[].

2. Step 2: Delete outer array

   The matrix pointer itself is an array of pointers allocated with new int*[3], so delete with delete[] matrix;.

3. Final Answer:

   for (int i = 0; i < 3; ++i) delete[] matrix[i]; delete[] matrix; -> Option A

4. Quick Check:

   Match new[] with delete[] at all levels [OK]

Hint: Delete inner arrays with delete[], then outer with delete[] [OK]

Common Mistakes:

• Using delete instead of delete[] for inner arrays
• Deleting outer array with delete instead of delete[]
• Forgetting to delete inner arrays causing leaks