delete keyword in C++ (original) (raw)
Last Updated : 11 Jul, 2025
delete is an **operator that is used to **destroy array and **non-array(pointer) **objects which are dynamically created by the **new operator.
- **delete can be used by either using the **delete operator or **delete [ ] operator.
- The **new operator is used for dynamic memory allocation which stores variables on heap memory.
- This means the delete operator deallocates memory from the **heap.
- The pointer to the object is not destroyed, the value or memory block pointed by the pointer is destroyed.
- The delete operator has **void return type which means it does not return any value.
**Below are some examples of where we can apply the delete operator:
1. Deleting Array Objects
We delete an array using [] brackets.
C++ `
// Program to illustrate deletion of array
#include <bits/stdc++.h> using namespace std;
int main() { // Allocate Heap memory int* array = new int[10];
// Deallocate Heap memory
delete[] array;
return 0;}
`
2. Deleting NULL Pointer
Deleting a NULL does not cause any change and gives no error.
C++ `
// C++ program for deleting // NULLL pointer
#include <bits/stdc++.h> using namespace std;
int main() { // ptr is NULL pointer int* ptr = NULL;
// deleting ptr
delete ptr;
return 0;}
`
3. Deleting Pointer With or Without Value
The memory pointed out by the specified pointer will be deallocated from the heap memory.
C++ `
// C++ program for deleting pointer with or without value
#include <bits/stdc++.h> using namespace std;
int main() { // Creating int pointer int* ptr1 = new int;
// Initializing pointer with value 20
int* ptr2 = new int(20);
cout << "Value of ptr1 = " << *ptr1 << "\n";
cout << "Value of ptr2 = " << *ptr2 << "\n";
// Destroying ptr1
delete ptr1;
// Destroying ptr2
delete ptr2;
return 0;}
`
Output
Value of ptr1 = 0 Value of ptr2 = 20
4. Deleting a Void Pointer
The delete operator does not only deallocate the memory, but it also calls the destructor of the object to be deleted. That is why, if we use void pointer with delete, it will lead to undefined behaviour.
C++ `
// C++ prgram for deleting a void pointer
#include <bits/stdc++.h> using namespace std; int main() { // Creating void pointer void* ptr; // Destroying void pointer delete ptr;
cout << "ptr deleted successfully";
return 0;}
`
Output
ptr deleted successfully
5. Deleting Memory Dynamically Allocated by malloc()
Deallocating memory allocated by malloc() using the delete operator also leads to undefined behavior. It is recommended to use delete for new and free() for malloc.
C++ `
// C++ program for deleting memory dynamically allocated by // malloc
#include <bits/stdc++.h> using namespace std;
int main() { // Dynamic memory allocated by using malloc int* ptr2 = (int*)malloc(sizeof(int));
delete ptr2;
cout << "ptr2 deleted successfully";
return 0;}
`
Output
ptr2 deleted successfully
**Note: Although the above program runs fine on GCC. It is not recommended to use delete with malloc().
6. Deleting Variables of User-Defined Data Types
C++ `
// C++ program for deleting variables of User Defined data // types
#include <bits/stdc++.h> using namespace std;
struct P { // Overloading delete operator for single object // deallocation static void operator delete(void* ptr, size_t sz) { cout << "custom delete for size " << sz << endl; // ::operator delete(ptr) can also be used ::operator delete(ptr); }
// Overloading delete operator for array deallocation
static void operator delete[](void* ptr, size_t sz)
{
cout << "custom delete for size " << sz << endl;
// ::operator delete(ptr) can also be used
::operator delete(ptr);
}};
int main() { P* var1 = new P; delete var1;
P* var2 = new P[10];
delete[] var2;}
`
Output
custom delete for size 1 custom delete for size 18
**Exceptions
1. Trying to Delete a Non-Pointer Object
C++ `
// C++ program for trying to delete a Non-pointer object
#include <bits/stdc++.h> using namespace std;
int main() { int x;
// Delete operator always
// requires pointer as input
delete x;
return 0;}
`
**Output
error: type ‘int’ argument given to ‘delete’, expected pointer
2. Trying to Delete the Pointer to a Local Stack-Allocated Variable
C++ `
// C++ program for trying to delete the pointer to a local // stack-allocated variable
#include <bits/stdc++.h> using namespace std;
int main() { int x; int* ptr1 = &x;
// x is present on stack frame as
// local variable, only dynamically
// allocated variables can be destroyed
// using delete operator
delete ptr1;
return 0;}
`
**Output
main.cpp: In function ‘int main()’:
main.cpp:16:12: warning: ‘void operator delete(void*, std::size_t)’ called on unallocated object ‘x’ [-Wfree-nonheap-object]
16 | delete ptr1;
| ^~~~
main.cpp:9:9: note: declared here
9 | int x;
| ^
free(): invalid pointer