Delete on already deleted object : behavior?

Question

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 ?

Solution 1

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.

Solution 2

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.

Solution 3

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.

Solution 4

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.

View more solutions

Comments

[Filip Roséen - refp]

"likely crash" is an understatement, UB could make a raptor jump through your window and make the universe implode.

[sharptooth]

@refp: I know, but newbies usually don't believe that.

[David Schwartz]

I disagree with the advice. For one thing, it will likely make the problem much worse because you will get in the habit of thinking that if you have a pointer with a non-NULL value, it's safe to delete it, which it certainly is not. (See sharptooth's answer for an example.)

[Joe McGrath]

Your answer is misleading, are you saying delete sets a pointer to 0? It doesn't. delete ptr;delete ptr; is just as dangerous.

[GManNickG]

That will only silence the error. Let it crash so you can get rid of the double-delete/be reminded to use smart pointers.

[sharptooth]

@Joe McGrath: No, I'm not saying that. The problem with delete ptr; delete ptr; is that people reject it as "stupid, noone does that".

[James Kanze]

@sharptooth I'm not sure about the "likely crash". At least one implementation I've used, the second delete would be a no-op. Unless the memory had already be reallocated, in which case the new owner is in for a bit of a surprise:-). As we all know, the most frequent "behavior" in the case of undefined behavior is for the program to work perfectly with all of your tests, then crash in the demo in front of the important client.

[Ludwik]

Exactly. The worst scenario with undefined behavior is not crashing or imploding the universe, it's when it's pretending to work well. I'd say just crashing is your best-case scenario.

[fyts]

There is an explanation here of what is the value that is set to the pointer after the deletion of an object.