C++ new and delete

🆕❌ C++ new and delete

In C++, new and delete are used for dynamic memory management—that is, allocating and freeing memory at runtime (on the heap).

🔹 1. Why new and delete?

  • Size of data not known at compile time

  • Memory needed dynamically (runtime)

  • Manual control over memory (powerful but risky)

🔹 2. Using new (Allocate Memory)

Allocate a Single Variable

int *p = new int;
*p = 10;

Or with initialization:

int *p = new int(10);

✔ Memory allocated on heap
✔ p stores the address

🔹 3. Using delete (Free Memory)

delete p;
p = nullptr;

✔ Frees heap memory
✔ Setting to nullptr avoids dangling pointer

🔹 4. Complete Example (Single Variable)

#include <iostream>
using namespace std;

int main() {
int *p = new int(25);

cout << *p << endl;

delete p;
p = nullptr;

return 0;
}

🔹 5. Dynamic Array Allocation (new[])

int *arr = new int[5];

Initialize dynamically:

for (int i = 0; i < 5; i++) {
arr[i] = i * 10;
}

🔹 6. Delete Dynamic Array (delete[])

delete[] arr;
arr = nullptr;

⚠️ Important rule

  • new → delete

  • new[] → delete[]

🔹 7. Complete Example (Dynamic Array)

#include <iostream>
using namespace std;

int main() {
int n = 5;
int *arr = new int[n];

for (int i = 0; i < n; i++) {
arr[i] = i + 1;
}

for (int i = 0; i < n; i++) {
cout << arr[i] << " ";
}

delete[] arr;
arr = nullptr;

return 0;
}

🔹 8. new vs Stack Allocation

int a = 10; // stack
int *p = new int(10); // heap
Stack Heap
Automatic Manual
Fast Slower
Limited Large
Safe Error-prone

🔹 9. Common Mistakes ❌

❌ Memory Leak

int *p = new int(10);
// delete missing

❌ Double Delete

delete p;
delete p; // undefined behavior

❌ Wrong Delete

int *arr = new int[5];
delete arr; // ❌ should be delete[]

✔ Correct:

delete[] arr;

🔹 10. new/delete vs Smart Pointers (Modern C++)

❌ Old style:

int *p = new int(10);
delete p;

✔ Modern C++:

#include <memory>
auto p = std::make_unique<int>(10);

✔ Automatic memory management
✔ No leaks

✅ Best Practices

  • Always pair new with delete

  • Always pair new[] with delete[]

  • Set pointer to nullptr after delete

  • Prefer smart pointers (unique_ptr, shared_ptr)

  • Avoid raw new/delete in modern C++

📌 Summary

  • new allocates memory on heap

  • delete frees allocated memory

  • new[] / delete[] for arrays

  • Incorrect usage leads to memory bugs

  • Prefer smart pointers when possible

You may also like...