如果你“删除这个”会发生什么； 在成员 function 中？

Question

What will exactly happen if a member function try to do delete this; , like in the constructor of the following class?

class A
{
public:
    A(int);
    ~A();
    int *pi;
}

A::A(int i)
{
    delete this;
    pi = new int(i);
}

A::~A()
{
    delete pi;
}

Answer 1

This C++ FAQ entry answers this quite nicely, repeating here:

As long as you're careful, it's OK for an object to delete this .

Here's how I define "careful":

• You must be absolutely 100% positively 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).
• You must be absolutely 100% positively sure that your member function will be the last member function invoked on this object.
• You must be absolutely 100% positively 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).
• You must be absolutely 100% positively 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.

You are violating the #3 by accessing pi after delete this

Answer 2

Bad things. You can delete this; but it's generally speaking an extremely bad idea, and once it's done, you cannot touch any member variables or member functions.

Answer 3

In general, invoking delete this from inside a member function is well-defined, if a little risky.

But it's probably a very bad idea to invoke it from the constructor (I don't know if it's well-defined). Why would you ever want to do that?

Answer 4

You can delete this , but this assumes that the instance was created with new and that you don't access any members of the instance any more.

In your example, pretty much the same would happen if you did

class A
{
public:
    A(int);
    int *pi;
};

A::A(int i)
{
    pi = new int(i);
}

int main()
{
   A* p = new A(10);
   delete p;
   p->pi = new int; //bad stuff

//or
   A a(20);
   delete &a;  //bad stuff
   a.pi = new int; //more bad stuff
}

And even more bad stuff happens because when you delete this , the pi member is unitialized, leading to destructor attempting to delete a dangling pointer.

Answer 5

It is a bad practice to use delete this, However, if used, then following points must be considered.

1) delete operator works only for objects allocated using new operator. If the object is created using new, then we can do delete this, otherwise behavior is undefined.

  class A {
   public:
    void fun(){
     delete this;
   }
  };

 int main(){
 /* Following is Valid */
   A *ptr = new A;
   ptr->fun();
    ptr = NULL // make ptr NULL to make sure that things are not accessed using ptr. 


   /* And following is Invalid: Undefined Behavior */
    A a;
    a.fun();

 return 0;
}

2) Once delete this is done, any member of the deleted object should not be accessed after deletion.

 class A {
   int x;
  public:
    A() { x = 0;}
     void fun() {
      delete this;

    /* Invalid: Undefined Behavior */
    cout<<x;
  }
 };