Memory leak concept in C++ - Step-by-Step Execution

Concept Flow - Memory leak concept

Allocate memory with new

↓

Use the allocated memory

↓

Forget to delete memory

↓

Memory still reserved

↓

Program continues, memory not freed

↓

Memory leak occurs

This flow shows how memory is allocated but not freed, causing a memory leak.

Execution Sample

C++

int* ptr = new int(10);
// use ptr
// forgot to delete ptr
// memory leak occurs

This code allocates memory for an int but never frees it, causing a memory leak.

Execution Table

Step	Action	Memory Allocated	Pointer Value	Memory Freed	Leak Status
1	Allocate memory with new int(10)	1 int block	Address 0x1000	No	No
2	Use the allocated memory	1 int block	Address 0x1000	No	No
3	Forget to delete pointer	1 int block	Address 0x1000	No	Yes
4	Program continues	1 int block	Address 0x1000	No	Yes

💡 Memory was never freed, so leak remains until program ends.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
ptr	nullptr	0x1000	0x1000	0x1000	0x1000

Key Moments - 2 Insights

Why does the memory leak happen even though we have a pointer?

Because the pointer 'ptr' still points to the allocated memory but we never call 'delete ptr' to free it, as shown in execution_table step 3.

Does the memory get freed automatically when the pointer goes out of scope?

No, in C++ you must manually free memory with 'delete'. The pointer going out of scope does not free the memory, causing a leak (see execution_table step 4).

Visual Quiz - 3 Questions

Look at the execution table, what is the pointer value after step 2?

A nullptr

B Address 0x2000

C Address 0x1000

D Deleted

💡 Hint

Check the 'Pointer Value' column at step 2 in the execution_table.

At which step does the memory leak start to exist?

A Step 2

B Step 3

C Step 1

D Step 4

💡 Hint

Look at the 'Leak Status' column in the execution_table.

If we add 'delete ptr;' after step 2, how would the 'Memory Freed' column change at step 3?

A Changes to Yes

B No change, still No

C Pointer value becomes nullptr

D Leak status becomes Yes

💡 Hint

Deleting pointer frees memory, so 'Memory Freed' becomes Yes at step 3.

Concept Snapshot

Memory leak in C++ happens when you allocate memory with 'new' but forget to free it with 'delete'.
Pointer still holds address but memory stays reserved.
Program loses track of memory, causing leak.
Always pair 'new' with 'delete' to avoid leaks.
Memory leaks waste resources and can crash programs.

Full Transcript

This visual execution shows how memory leaks happen in C++. First, memory is allocated using 'new', and a pointer stores its address. The program uses this memory. However, if the programmer forgets to call 'delete' on the pointer, the memory remains allocated even after the pointer is no longer used. This causes a memory leak because the program cannot reuse or free that memory. The pointer variable itself does not free memory automatically when it goes out of scope. To prevent leaks, every 'new' must be matched with a 'delete'.

Practice

1.

What is a memory leak in C++?

easy

A. When variables are declared but not used

B. When a program runs too fast

C. When allocated memory is not released back to the system

D. When the program uses too many functions

Solution

1. Step 1: Understand memory allocation

   Memory allocated with new must be freed with delete.

2. Step 2: Define memory leak

   If memory is allocated but not freed, it stays reserved and causes a leak.

3. Final Answer:

   When allocated memory is not released back to the system -> Option C

4. Quick Check:

   Memory leak = not freeing allocated memory [OK]

Hint: Memory leak means forgetting to free allocated memory [OK]

Common Mistakes:

• Confusing memory leak with slow program
• Thinking unused variables cause leaks
• Mixing memory leak with logical errors

2.

Which of the following C++ code snippets correctly frees allocated memory?

int* ptr = new int(5);
// What should be done next?

easy

A. free(ptr);

B. delete ptr;

C. ptr = nullptr;

D. ptr = new int(10);

Solution

1. Step 1: Identify allocation method

   Memory is allocated with new, so it must be freed with delete.

2. Step 2: Match correct freeing syntax

   free() is for malloc(), not new. Setting pointer to nullptr does not free memory.

3. Final Answer:

   delete ptr; -> Option B

4. Quick Check:

   Use delete for new, free for malloc [OK]

Hint: Use delete for new, not free [OK]

Common Mistakes:

• Using free() with new
• Just setting pointer to nullptr without delete
• Allocating new memory without deleting old

3.

What is the output of this C++ code?

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

medium

A. 10

B. Compilation error

C. Undefined behavior

D. 20

Solution

1. Step 1: Analyze pointer reassignment

   First, ptr points to 10. Then ptr is reassigned to new int(20) without deleting old memory.

2. Step 2: Determine output

   Pointer now points to 20, so output is 20. The old memory is leaked but does not affect output.

3. Final Answer:

   20 -> Option D

4. Quick Check:

   Pointer points to last new value = 20 [OK]

Hint: Pointer shows last assigned value, old memory leaks [OK]

Common Mistakes:

• Expecting output 10 after reassignment
• Thinking code causes compile error
• Confusing memory leak with runtime error

4.

Find the memory leak in this code and fix it:

void func() {
  int* arr = new int[5];
  arr = new int[10];
  delete[] arr;
}

medium

A. Delete first array before reassigning arr

B. Use delete instead of delete[]

C. No leak, code is correct

D. Change new int[10] to new int(10)

Solution

1. Step 1: Identify memory allocations

   First, arr points to array of 5 ints, then reassigned to array of 10 ints without deleting first.

2. Step 2: Fix memory leak

   Delete the first array before reassigning arr to avoid leak. Use delete[] for arrays.

3. Final Answer:

   Delete first array before reassigning arr -> Option A

4. Quick Check:

   Delete old array before new assignment [OK]

Hint: Delete old array before assigning new to pointer [OK]

Common Mistakes:

• Not deleting first allocated array
• Using delete instead of delete[] for arrays
• Ignoring memory leak warnings

5.

You have a class that allocates memory in its constructor using new. Which approach best prevents memory leaks?

hard

A. Use smart pointers like std::unique_ptr to manage memory automatically

B. Manually call delete in destructor and follow Rule of Three

C. Use malloc and free instead of new and delete

D. Never use new, only stack variables

Solution

1. Step 1: Understand manual memory management risks

   Manually calling delete and following Rule of Three is error-prone and can cause leaks if forgotten.

2. Step 2: Use smart pointers for safety

   Smart pointers automatically free memory when no longer used, preventing leaks safely and easily.

3. Final Answer:

   Use smart pointers like std::unique_ptr to manage memory automatically -> Option A

4. Quick Check:

   Smart pointers prevent leaks automatically [OK]

Hint: Use smart pointers to avoid manual delete [OK]

Common Mistakes:

• Relying only on manual delete
• Avoiding new but not managing memory
• Mixing malloc/free with new/delete