C++ Dynamic Memory Management – Control Memory with new and delete

Introduction – Why Dynamic Memory Management Matters in C++

C++ allows fine-grained control over how and when memory is allocated and released. Unlike automatic (stack) memory, dynamic memory is allocated at runtime on the heap using new and deallocated using delete. This is essential for building scalable, high-performance applications with variable-sized structures and long-living objects.

In this guide, you’ll learn:

• What dynamic memory is and how it works
• How to use new, delete, new[], delete[]
• Memory leaks, dangling pointers, and safe handling
• Best practices and real-world use cases

What Is Dynamic Memory in C++?

Dynamic memory is memory allocated during runtime instead of compile-time. It’s used when:

• The size of data is unknown in advance
• Objects must live beyond the function scope

Allocated using new, released using delete.

Code Examples – With Output

Example 1: Dynamic Allocation of a Single Integer

#include <iostream>
using namespace std;

int main() {
    int* ptr = new int(42);  // allocate memory and assign 42
    cout << *ptr << endl;
    delete ptr;              // free memory
    return 0;
}

Output:

42

Example 2: Dynamic Array Allocation

int* arr = new int[5];   // allocate array of 5 ints
for (int i = 0; i < 5; i++) arr[i] = i + 1;
delete[] arr;            // use delete[] for arrays

new and delete Syntax

Common Issues & How to Avoid Them

Memory Leak

Occurs when new is used but delete is never called.
Use smart pointers (like unique_ptr) or ensure delete is always paired.

Dangling Pointer

Occurs when you access memory after deleting it.
Set pointers to nullptr after deleting them.

Double Delete

Calling delete on the same pointer twice.
Use nullptr checks: if (ptr) delete ptr;

Dynamic vs Automatic Memory

Best Practices & Tips

Best Practice: Always pair new with delete, and new[] with delete[].

Tip: Prefer smart pointers like std::unique_ptr or std::shared_ptr for automatic cleanup.

Pitfall: Don’t use delete on memory not allocated with new.

Use Cases for Dynamic Memory

Variable-Size Data: Allocate memory for arrays or matrices whose size is determined at runtime
Long-Lived Objects: Objects that must persist beyond function calls or scopes
Data Structures: Linked lists, trees, graphs often require dynamic nodes
Object Pools: Reuse memory efficiently in real-time systems

Summary – Recap & Next Steps

Key Takeaways:

• Dynamic memory in C++ gives runtime control via new and delete
• Always manage memory safely to avoid leaks and crashes
• Smart pointers are a modern, safer alternative

Real-World Relevance:
Used in game engines, data processing, large-scale applications, and memory-intensive systems like simulations and device drivers.

Next Steps:
Learn about C++ Smart Pointers to manage dynamic memory safely and automatically.

FAQ – C++ Dynamic Memory Management

What is the difference between delete and delete[]?
delete deallocates a single object, while delete[] deallocates arrays created with new[].

Can I use malloc in C++?
Yes, but it’s not recommended—use new/delete or smart pointers for type safety and constructors.

Is dynamic memory automatically freed when a program ends?
Yes, but this is not safe practice. Always delete what you new.

How can I prevent memory leaks?
Use smart pointers (unique_ptr, shared_ptr) or always match new with delete.

What happens if new fails?
It throws std::bad_alloc unless new (nothrow) is used.