Dynamic Memory in C++ (new, delete)

In this lesson: Allocate memory with new and free with delete in C++ — arrays, memory leaks and best practices. In Hindi & English.

Why dynamic memory?

Normal variables have a size fixed when you write the code. But sometimes you only learn how much memory you need while the program runs — for example an array sized by user input. Dynamic memory lets you request memory at run time from the heap.

Allocating with new

new reserves memory on the heap and returns a pointer to it:

int *p = new int;      // one int on the heap
*p = 42;
cout << *p << "\n";     // 42

Freeing with delete

Heap memory is not freed automatically. You must return it with delete when done — every new needs a matching delete:

int *p = new int(42);
cout << *p << "\n";
delete p;              // free it
p = nullptr;           // avoid a dangling pointer

Dynamic arrays

Use new type[size] to make an array whose size is decided at run time — and free it with delete[]:

int n = 5;
int *a = new int[n];        // array of n ints
for (int i = 0; i < n; i++) a[i] = i * 10;
for (int i = 0; i < n; i++) cout << a[i] << " ";
delete[] a;                 // note the [] for arrays

Memory leaks & dangling pointers

• A memory leak is forgetting to delete, so the memory stays reserved forever.
• A dangling pointer is a pointer still holding an address after that memory was freed — using it is undefined behaviour.

Setting a pointer to nullptr right after delete avoids accidental dangling use.

Smart pointers

Modern C++ prefers smart pointers — unique_ptr and shared_ptr from <memory> — which free their memory automatically when they go out of scope, so you cannot forget to delete:

#include <memory>
auto p = make_unique<int>(42);   // frees itself automatically
cout << *p;

See the smart pointers lesson for details.

Common mistakes

• Forgetting delete — a memory leak.
• Calling delete twice on the same pointer (double free).
• Using delete instead of delete[] for arrays.
• Using a pointer after it was deleted (dangling pointer).

Summary

• Dynamic memory is allocated at run time on the heap with new.
• Every new needs a matching delete; new[] needs delete[].
• Forgetting to free causes a memory leak; using freed memory is a dangling pointer.
• Set pointers to nullptr after deleting.
• Prefer smart pointers, which free memory automatically.