Memory leak in C++

Last Updated : 20 Jun, 2026

A memory leak occurs when dynamically allocated memory is not released after it is no longer needed. Since the memory remains allocated, it cannot be reused until the program terminates.

  • Occurs when dynamically allocated memory is not deallocated.
  • Leads to unnecessary memory consumption and reduced available memory.

Example: The following program allocates memory dynamically but never releases it.

C++ 
#include <iostream>
using namespace std;

void func() {
    // Allocate memory
    int* ptr = new int[10];

    // Memory is never released
    return;
}

int main() {
    func();
    return 0;
}

Explanation

  • new int[10] allocates memory for an array of 10 integers.
  • The pointer ptr goes out of scope when func() returns.
  • Since delete[] is never called, the allocated memory cannot be accessed or reused, resulting in a memory leak.

Causes of Memory Leaks

Memory leaks occur because C++ does not provide automatic garbage collection for dynamically allocated memory.

  • Forgetting to release memory allocated using new.
  • Losing the pointer to dynamically allocated memory before deleting it.
  • Returning from a function before releasing allocated memory.
  • Overwriting a pointer without freeing the previously allocated memory.

Consequences of Memory Leaks

Memory leaks gradually reduce the amount of available memory and may affect both the program and the operating system.

  • Reduced Performance: Less memory is available for the program and other applications.
  • Program Crashes: Excessive memory usage may cause the program to become unstable or terminate.
  • Resource Depletion: Memory remains occupied even though it is no longer required.
  • Greater Impact on Long-Running Programs: Applications such as servers and background services continue accumulating leaked memory over time.

Preventing Memory Leaks

Memory leaks can be avoided by properly managing dynamically allocated memory.

  • Always pair every new with the corresponding  delete or delete[].
  • Prefer smart pointers instead of raw pointers whenever possible.
  • Use constructors and destructor to manage resources in class  (RAII).
  • Assign nullptr to pointers after deleting them when appropriate.
  • Avoid overwriting pointers without first releasing the previously allocated memory.

Detecting Memory Leaks

Memory leaks can be identified by reviewing code or by using specialized debugging tools.

  • Perform careful code reviews to ensure every allocation has a matching deallocation.
  • Use tools such as Valgrind, AddressSanitizer (ASan), or IDE memory analyzers to detect leaked memory during program execution.

Related Article: Detect Memory Leaks in C++

Comment

Explore