Is "delete this" a bad idea? [duplicate]

This question already has answers here: Closed 11 years ago.

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?

---

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.

---

Using delete this is a bad idea if one is not sure of the pitfalls & working around them.

Once you call delete this the object's destructor is going to be invoked and the dynamically allocated memory will be freed.

If the object was not allocated using new, it will be a Undefined behaviour.
If any of object's data members or virtual functions are accessed after delete this, the behaviour will be Undefined Behavior again.

Probably, It is best to avoid delete this given the above.

---

It's actually a frequent idiom, and about as safe as any delete. As with all deletes, you have to ensure that no further code tries to access the object, and you have to be sure that the object was dynamically allocated. Typically, however, the latter is not a problem, since the idiom is only relevant for objects which have a lifetime determined by the semantics of the object, and such objects are always allocated dynamically. Finding all of the pointers too the object can be an issue (whether delete this is used or not); usually, some form of the observer pattern will be used to notify all interested parties that the object will cease to exist.

---

The idiomatic way of doing that in C++ is by putting the cleanup code in the destructor then let it be called automatically when you delete the object.

Class::~Class() {
    do_cleanup();
}

void ManagingClass::deleteNode(Class* instance) {
    delete instance; //here the destructor gets called and memory gets freed
}

---

There's a simple way of doing the same thing that doesn't involve undefined behavior:

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