Question

Possible Duplicate:
Is it safe to delete this?

I’ve been doing a little work on a class that’s designed to act as a node in a linked list, and I figured I’d give the class its own deletion function as opposed to the managing class doing it. So basically it goes like this:

void Class::Delete() {
    //Some cleanup code before deleting the object
    delete this;
}

Now I’ve tested this and it appears to work fine, but I’ve had a problem in the past where objects have been in the middle of running code, been deleted, then obviously crashed the program by trying to use a no-longer-existing object.

Since “delete this” is right at the end of the function, it obviously exits the function and works fine, but is this sort of practice a bad idea at all? Could this ever blow up in my face if I’m not careful?

Answer 1

The FAQlite answers this quite well:

As long as you’re careful, it’s OK for
an object to commit suicide (delete
this).

Here’s how I define “careful”:

1. You must be absolutely 100% positive sure that this object was
   allocated via new (not by new[], nor
   by placement new, nor a local object
   on the stack, nor a global, nor a
   member of another object; but by plain
   ordinary new).
2. You must be absolutely 100% positive sure that your member
   function will be the last member
   function invoked on this object.
3. You must be absolutely 100% positive sure that the rest of your
   member function (after the delete this
   line) doesn’t touch any piece of this
   object (including calling any other
   member functions or touching any data
   members).
4. You must be absolutely 100% positive sure that no one even touches
   the this pointer itself after the
   delete this line. In other words, you
   must not examine it, compare it with
   another pointer, compare it with NULL,
   print it, cast it, do anything with
   it.

Naturally the usual caveats apply in
cases where your this pointer is a
pointer to a base class when you don’t
have a virtual destructor.

Basically, you need to take the same care as you do with deleteing any other pointer. However, there are more areas where things can go wrong with a member function committing suicide, compared with an explicitly-declared pointer.