delete object from inside object

[Drogin]

Is it possible to delete an object from inside an object?
I know this is extremely ugly. I am just curious.

Something like this:

class Test {
  public:
void  reload();
};

void Test::reload() {
  Test *helper = this;
   delete this;
   helper = new Test();
}

This is probably all very wrong..I just wrote this code to illustrate what I mean.
But is it some way to do something similar?

[CornedBee]

It's possible for an object to delete itself, but what you're attempting to do is not possible. An object cannot "reload" itself. What you're doing in reload() is:
1) Create a temporary pointer "helper" and make it point to the current object.
2) Delete the current object. Now you may no longer access any member variables or call any functions!
3) Create a new Test object and have "helper" point to it. This makes the initialization of "helper" a dead store.
4) Return from the function, leaking the new Test object.

In particular, what this function does not do is change what "this" points to or what any external pointers to the current object point to (except that they're now invalid).

[C_ntua]

It is probably not good to "reload" an object since you reallocate memory. You would probably want to have an initializer function and just reinitialize every member variable. But This might work and I don't find ugly.

class Test {
  public:
  void  reload();
};

Test* Test::reload() {
   delete this;
   return new Test();
}

//main
Test* t = new Test();
t = t.reload();

The question is if this would work:

void Test::reload() {
   delete this;
   this = new Test();
}

which I would bet that wouldn't work...

[anon]

If you want to revert to the default-constructed object you can just assign one to *this.

#include <string>
#include <iostream>

struct Test
{
    std::string msg;
    Test(): msg("Life, universe, everything?") {}

    void reload()
    {
        *this = Test();
    }
};

int main()
{
    Test a;
    std::cout << a.msg << '\n';
    a.msg = "42";
    std::cout << a.msg << '\n';
    a.reload(); //same as: a = Test();
    std::cout << a.msg << '\n';
}

(You might also swap current instance with a default-constructed temporary, if you provide an efficient swap method.)

[R.Stiltskin]

Why not simply reset the member variables to their default-constructed values (and delete any dynamically-allocated memory within the object)?

[CrazyNorman]

It is probably not good to "reload" an object since you reallocate memory. You would probably want to have an initializer function and just reinitialize every member variable. But This might work and I don't find ugly.

class Test {
  public:
  void  reload();
};

Test* Test::reload() {
   delete this;
   return new Test();
}

//main
Test* t = new Test();
t = t.reload();

The question is if this would work:

void Test::reload() {
   delete this;
   this = new Test();
}

which I would bet that wouldn't work...

Any form of "delete this" is never safe, because the object does not know whether it is allocated on the stack or on the heap. If it is allocated on the stack, first off, the destructor will be called twice (once then, once when the stack unwinds), and second, you are attempting to free memory which you have not allocated, which will most likely result in a segfault.

[Elysia]

//main
Test* t = new Test();
t = t.reload();

The question is if this would work:

void Test::reload() {
   delete this;
   this = new Test();
}

which I would bet that wouldn't work...

It does not. this is a const pointers if I am not mistaken.

Any form of "delete this" is never safe, because the object does not know whether it is allocated on the stack or on the heap. If it is allocated on the stack, first off, the destructor will be called twice (once then, once when the stack unwinds), and second, you are attempting to free memory which you have not allocated, which will most likely result in a segfault.

A "delete this" can be safe and can have its uses, but one must be careful in doing so. One thing you must never do is as you mention: never create it on the stack.
http://www.parashift.com/c++-faq-lit...html#faq-16.15

[CornedBee]

It does not. this is a const pointers if I am not mistaken.

More importantly, (but less easy to understand for non-language-lawyers,) 'this' is not an lvalue.

[iMalc]

Does the actual class you want to do this on follow the rule of three?
I.e. if it has a copy-constructor, destructor, or assignment operator (and these are needed), does it have all three?
This is the more important question here. If the class does not follow the rule of three then it is already broken.
If it does follow the rule of three, and it has a default constructor, then you can trivially do this:

Test t(some, funky, constructor, arguments);
// or other things done to t...

t = Test(); // Back to defaults again - woo!

[matsp]

Why not simply reset the member variables to their default-constructed values (and delete any dynamically-allocated memory within the object)?

Sounds like a good plan, and if you do it right, you could re-use the same code for both things:

class Something
{
   private:
      int x;
      sometype *ptr;
     void Initialize()
     {
         x = 42;
         ptr = NULL;
     }
   public:
     Something()  
     {
         Initialize();
     }
     void Reload()
     {
        Initialize();
     }
};

--
Mats

[King Mir]

Matsp's show how the problem is generally solved.

You can principally do something like this:

class Test {
  public:
void  reload();
};

void Test::reload() {
   this->~Test();
   new (this) Test();
}

But I cannot think of a case where this solution is better.