CODEWITHSUNDEEP
c++pointersmemory-managementdelete-operator
Jérémy Dutheil
Jérémy Dutheil

Reputation: 6137

Delete on already deleted object : behavior?

I am wondering what will hapen if I try to do a delete on a pointer that is already deleted, or may have not been allocated ? I've read two things : first, that delete operator will do some checkings and we do not need to check if the pointer is null ; and then, I read that it can lead to unknown behaviors..

I'm asking it, because I use some personal objects that contains Qt objects attributes ; I think that Qt delete all widgets associated when we close the window, but I'm not pretty sure and still : if the soft crash before the window's close, we have to delete all objects manually.

So, what would be the best solution ? Something like that ?

if( my_object )
    delete my_object;

Can it avoid dangerous behaviours ?

Upvotes: 10

Views: 15983

Answers (6)

Luchian Grigore
Luchian Grigore

Reputation: 258648

if( my_object )
    delete my_object;

is redundant. delete on a NULL pointer does nothing. This is guaranteed by the standard.

delete on a pointer that was already deleted causes undefined behavior. That's why you should always remember to assign your pointers to NULL after you delete them:

delete p;
p = NULL;

EDIT: As per the comments, I feel I should specify this. If you have multiple pointers to the same object, the assignment to NULL won't make the delete safe. Regardless, it's better to use smart pointers.

Upvotes: 4

Tobias Langner
Tobias Langner

Reputation: 10828

Just to combine the answers above:

  • if (my_object) checks the value of the pointer, not the existence of the object. If it is already deleted, the pointer may still point to that location.
  • deleting an already deleted object is undefined behavior and will probably crash your program.
  • deleting NULL is defined and does nothing. Together with point 1 this explains the answer of Luchian.

To sum it up: You have to be clear on who owns the object and where the different pointer to the object are. When you delete an object, make sure to set all pointer pointing to that location to 0/NULL. Use managing objects like boost::shared_pointer or QPointer to help you in this task.

Upvotes: 0

Roee Gavirel
Roee Gavirel

Reputation: 19473

the right way is: 

if( my_object )
{
    delete my_object;
    my_object = NULL;
}

because, calling twice the way it was before will call delete on a deleted pointer.

Upvotes: 1

Jan
Jan

Reputation: 1847

Please note that deleting a pointer does not set it to NULL.

int* i = new int;
*i = 42;
delete i;
delete i; // oops! i is still pointing to the same memory, but it has been deleted already

Deleting a null pointer doesn't do anything, deleting an already deleted object will result in undefined behaviour.

Upvotes: 1

Alok Save
Alok Save

Reputation: 206636

It results in Undefined Behavior if you call delete on already deleted pointer.
Calling delete on a NULL pointer has no-effect though.

Standard c++03 § 3.7.4.2-3

If a deallocation function terminates by throwing an exception, the behavior is undefined. The value of the first argument supplied to a deallocation function may be a null pointer value; if so, and if the deallocation function is one supplied in the standard library, the call has no effect. Otherwise, the value supplied to operator delete(void*) in the standard library shall be one of the values returned by a previous invocation of either operator new(std::size_t) or operator new(std::size_t, const std::nothrow_-t&) in the standard library, and the value supplied to operator delete[](void*) in the standard library shall be one of the values returned by a previous invocation of either operator new[](std::size_t) or operator new[](std::size_t, const std::nothrow_t&) in the standard library.

Using RAII & Smart Pointers are your best weapons to avoid such problems.

Upvotes: 0

sharptooth
sharptooth

Reputation: 170549

delete on an already deleted non-null pointer is undefined behavior - your program will likely crash. You can safely use delete on a null pointer - it will yield a no-op.

So the real problem is not delete on a null pointer. The real problem is here:

 ptr = new Something();
 otherPtr = ptr;
 delete ptr;
 delete otherPtr;

This can happen if you have several pointers to the same object and it is quite dangerous. The possible solutions are:

  • use smart pointers (no delete in your code) or
  • only have one designated pointer for controlling each object lifetime and delete at exactly the right time.

Upvotes: 20

Related Questions