delete this ? what does it do?

Question

Given the following :

#include <iostream>
using namespace std;

class A
{
public:
    void func() {delete this;}
    A() : x(5) {cout << "ctor A" << endl;}
    ~A() {cout << "dtor A" << endl;}
    int x;
};

int main() {
    A a;
    cout << "The X value: " << a.x << endl;
    a.func();  // calling 'delete this' ->going to the dtor #1
    cout << "The X value: " << a.x << endl;
    return 0;  
}

the output is :

ctor A
The X value: 5
dtor A
The X value: 5
dtor A

Does delete this; has any drastic repercussions?

Trying to delete something that hasn't been allocated via new: wrong. Trying to access something after it has been deleted: wrong. — sellibitze, Aug 28 '11 at 10:24
I agree with you , all I wanted to show was that the object still holds the value for "x" even after the first delete call ... just looked a little weird to me. — Ron_s, Aug 28 '11 at 10:28
The "x" value MIGHT have a value of 5, or it might not. And the application might or might not crash. See this classic of an explanation: http://stackoverflow.com/questions/6441218/can-a-local-variables-memory-be-accessed-outside-its-scope/6445794#6445794 — Andrew Shepherd, Aug 28 '11 at 10:37
I was curious ,too.I knew that it's a no-no ! Just wanted to know why. — Ron_s, Aug 28 '11 at 10:46
Related: [Object-Oriented Suicide](http://stackoverflow.com/questions/3959634/object-oriented-suicide-or-delete-this) — Armen Tsirunyan, Aug 29 '11 at 13:40
possible duplicate of [C++: Delete this?](http://stackoverflow.com/questions/3150942/c-delete-this) — Quentin, Aug 11 '15 at 15:13

score 5 · Answer 1 · answered Aug 28 '11 at 10:19

In this case (you did not allocate the A object via new) you are invoking undefined behaviour. Undefined behaviour is usually a very very bad thing. Basically, anything can happen.

It is possible to write code where a "delete this;" would be fine, though. But I can't recall ever doing this. Try to avoid it. Try avoiding to call delete manually altogether (whether you used new or not) by delegating this responsibility to some other object (for example, a smart pointer).

Andrew Shepherd · Answer 2 · 2011-08-28T10:40:21.617

I'll look past that you're calling delete on a stack-allocated object, and examine the usage of delete this in general.

There is a school of thought that says "It's not a good idea". However, I have seen it used a number of times with implementations of reference counted objects.

In COM, the framework requires that all objects would be created by a factory method, and then released again by a call to "Release".

  class MyRefCountedObject : public IUnknown
  {
      private:
           // Making the constructor and destructor private
           // so that the object can only be allocated as a pointer

           MyRefCountedObject() {}

           ~MyRefCountedObject() {}

           MyRefCountedObject(const MyRefCountedObject& mrco) {}

            int _refCount;
      public:
           static MyRefCountedObject* CreateInstance()
           {
                MyRefCountedObject* pObject = new MyRefCountedObject();
                pObject->_refCount = 1;
                return pObject;
           }

           void Release()
           {
                if(--_refCount == 0)
                {
                    delete this;
                }
           };
           void AddRef()
           {
               ++_refCount;
           }
  }

Note - that is not a complete implementation, just giving an idea of the logic. But, by making the constructor private, I can ensure that this would only ever be allocated on the heap.

score 3 · Answer 3 · answered Aug 28 '11 at 10:29

The delete operator call the destructor of the object then release the underlying memory used by the object. The memory must have been allocated by the new operator. In delete this, the object deleted is just the current object. There is nothing special about the construction, it is just plain C++.

In your exemple, the memory is from the stack, and thus your enter the realm of undefined behavior (since you're calling the delete operator on an object that was not allocated via the new operator).

It is generally considered bad design to call delete this because an object should not be responsible of its own lifetime. It is generally considered best practice to have the creator of an object responsible of its destruction.

However, there is one situation where I personally find it really useful. This happens when you have thread communicating by sending messages. In this case, if the message is responsible of its own lifetime it is actually safer and easier to write than having the original thread responsible for it.

Got it . Then why does "a.x" still holds the value "5" after the first delete call ? why the program did not crash ? — Ron_s, Aug 28 '11 at 10:34
Well, when you reach undefined behavior, anything can happen, even having the program work like you would expect. Since you don't have a destructor, the value was not changed, and since the object is on the stack the object is still reachable. However, you probably corrupted your allocator. But there is nothing guaranteed, this is the root of UB. — Sylvain Defresne, Aug 28 '11 at 10:37

score 2 · Answer 4 · answered Aug 28 '11 at 10:38

2

C++ FAQ Lite: "Is it legal (and moral) for a member function to say 'delete this'?"

That said, you should rarely if ever have a use for this in properly organized code.

answered Aug 28 '11 at 10:38

Karl Knechtel

62,466
11
102
153

score 0 · Answer 5 · answered Aug 28 '11 at 10:19

0

You should not do this. It is bad programming practice. The object that uses new should be the object that uses delete. Otherwise you get into a mess and end up with memory leaks etc.

answered Aug 28 '11 at 10:19

Ed Heal

59,252
17
87
127

Objects don't do anything. They merely exist. Functions do things. – curiousguy Sep 29 '11 at 21:53

delete this ? what does it do?

5 Answers5