easy way find that *this* is deleted

Code:

---

#include <iostream>
using namespace std;

class Test
{
public:
        void immortal() { cout << "I am Immortal!" << endl; }
};

int main()
{
        Test* t = new Test;
        t->immortal();
        delete t;
        t->immortal();
        return 0;
}

---

The above code works fine (in debug and non debug mode).
I have a similar situation in my project. Where an object gets deleted, and then a successful call to it's method is
made. But when that method tried to access some data member (in this case an integer)
my program crashed!

How to detect where the object gets deleted? There is no obvious hint form. Also function calls working fine confuse me more :(

Well since you have deleted "t", it no longer has the allocated memory from new, so it makes sense it crashed. Personally I would of done this also:

Code:

---

delete t;
t = NULL; // ensure the pointer holds nothing

---

no it does not crash at all! work fine!

but when i access a data member, only then the function seems to need *this* and that's when i get a crash.
and at that point i don't have the point of return, where i can go an check why was the object deleted?

Accessing a stray pointer is undefined behavior.

If you want to call a method after an object dies, make it a static member (a search friendly term) so that the behavior is defined.

Code:

---

#include <iostream>
class widget {
  public:
    static void f () { std::cout << "f(), call me anytime\n"; }
};

int main ()
{
  { // intentional scoping
    widget w;
    w.f();
  }
  widget::f();
}

---

Quote:

---

Originally Posted by manav

no it does not crash at all! work fine!

but when i access a data member, only then the function seems to need *this* and that's when i get a crash.
and at that point i don't have the point of return, where i can go an check why was the object deleted?

---

Functions are not stored inside the object. They exist outside the object, in the code space. Therefore, the compiler needs to pass the object's address to the function (the this parameter).
Since member variables are stored in the address of memory where this points to, you get a crash when trying to access them. But calling member function are perfectly valid without a crash. However, it's still undefined behavior.
A typical approach is to always set deleted objects to NULL and check before trying to dereference or call functions if the object is not NULL.

Of course, that doesn't help you if you access the dead object through a different pointer than the one you set to NULL. Which is why you really need more careful thought about object ownership and lifetimes.
Once you know how long an object lives and who's responsible for deleting it, you can use smart pointers to enforce these ideas.

i was actually calling the function through a reference. which was passed from multiple levels of function calls.
none of the function calls are direct. they use boost events to call each function in turn. say, on after another.
and i can not (as yet) find where the object gets destroyed midway, all i have is a reference which
succeeds calling the function and when that function tries to access a data member, my program crashes! :(

Easy. Track where the object still lives. Then put a breakpoint in the destructor.
You could also set a breakpoint condition to "this = (address of object)".
You just need to make sure the object is created first and then put the breakpoint and you should be able to find when it's destructed.