Self delete an object in C++

Question

Possible Duplicate:
C++: Delete this?
Object-Oriented Suicide or delete this;

I wonder if the code below is run safely:

#include <iostream>
using namespace std;

class A
{
public:
    A() {
        cout << "Constructor" << endl;
    }
    ~A() {
        cout << "Destructor" << endl;
    }

    void deleteMe() {
        delete this;
        cout << "I was deleted" << endl;
    }
};

int main()
{
    A *a = new A();
    a->deleteMe();
    cout << "Exit ...";
    return 0;
}

Output is:

Constructor
Destructor
I was deleted
Exit ...

and program exit normally, but are there some memory access violents here?

Answer 1

It's ok to delete this in case no one will use the object after that call. And in case the object was allocated on a heap of course

For example cocos2d-x game engine does so. It uses the same memory management scheme as Objective-C and here is a method of base object:

void CCObject::release(void)
{
    CCAssert(m_uReference > 0, "reference count should greater than 0");
    --m_uReference;

    if (m_uReference == 0)
    {
        delete this;
    }
}

I don't think it's a c++ way of managing memory, but it's possible

Answer 2

It's ok, because you have running simple method. After delete this, all variables and virtual table are clear. Just, analyze this example:

#include <iostream>

class foo
{
public:
    int m_var;
    foo() : m_var(1)  
    {

    }

    void deleteMe()
    {
        std::cout << m_var << "\n";
        delete this;
        std::cout << m_var << "\n"; // this may be crush program, but on my machine print "trash" value, 64362346 - for example
    }

    virtual void bar()
    {
        std::cout << "virtual bar()\n";
    }



  void anotherSimpleMethod()
    {
       std::cout << "anotherSimpleMethod\n";
    }

    void deleteMe2()
    {
        bar();
        delete this;
        anotherSimpleMethod();
        // bar(); // if you uncomment this, program was crashed, because virtual table was deleted
    }
};

int main()
{
    foo * p = new foo();
    p->deleteMe();
    p = new foo();
    p->deleteMe2();
    return 0;
}

I've can't explain more details because it's need some knowledge about storing class and methods in RAM after program is loaded.

Answer 3

Absolutelly, you just run destructor. Methods does not belongs to object, so it runs ok. In external context object (*a) will be destroyed.

Answer 4

When in doubt whether theres strange things going on in terms of memory usage (or similar issues) rely on the proper analysis tools to assist you in clarifying the situation.

For example use valgrind or a similar program to check whether there are memory leaks or similar problems the compiler can hardly help you with.

While every tool has its limitations, oftentimes some valuable insights can be obtained by using it.

Answer 5

There is no memory access violation in it, you just need to be careful. But deleting this pointer is not recommended at all in any language, even though the code above would work fine. As it is same as delete a, But try doing it other way, the safe way.

For example there is something illogical in your posted code itself.

void deleteMe() 
{
    delete this;
    cout << "I was deleted" << endl; // The statement here doesn't make any sense as you no longer require the service of object a after the delete operation 
}

EDIT: For Sjoerd

Doing it this way make more sense

 void deleteMe() 
{
    delete this;
}

 int main()
 {
 A *a = new A();
 a->deleteMe();
 cout << "a was deleted" << endl;
 cout << "Exit ...";
 return 0;
 }

The second line in your deleteMe() function should never be reached, but its getting invoked. Don't you think that its against the language's philosophy?