How to delete object itself(a dynamic list) by using a destructor

Supposed the class's design cannot be changed. There are dynamic list object linked together.

My destructor doesn't work ,why? Or we cannot use destructor to do so.

Hope you can help me.

Code:

class List{
public:
    List();
    ~List();


private:
    List *left;
    List *right;
    int data;


};
List::~List() {
    if (this == NULL)
        return;
    else {
        if (this->left != NULL) {
            delete this->left;
            left = 0;
        }
        if (this->right != NULL) {
            delete this->right;
            right = NULL;
        }


        delete this;
    }
}

?!?!:

Code:

if (this == NULL)

An object should never be testing for its own existence!

You seem to have missed the fact that this will call the destructor of the same object as it is already destructing.

Code:

        delete this;

Hence your destructor has infinite recursion.

Also, you should not check a pointer for NULL before calling delete. The NULL check is already built into delete itself as the first thing it does.
Likewise, you also don't NULL out pointer values in a destructor for the same reason you don't twink out every word on a printed document before you shred and burn it. (It's a pointless waste of time). And if you were going to pointlessly do it, you'd at least be consistent and not use a mixture of NULL and zero.

Finally, what you're trying to do is most easily and correctly accomplished with just two lines inside the destructor, both of which are delete statements, and not a single occurrence of "NULL" in sight.

Also I'm going to assume that list isn't a tree and doesn't need to be rotated a million times to delete, but you can delete a list with a simple loop.

Code:

while there are still nodes:
save a pointer to the next node
delete the current node
set the current node to the saved pointer
end while

Or delete it backwards, who cares.

I know you said don't change the interface, but this could be the content of a (private) utility function called "Clear".

O_o

This is idiotic.

Who thought this up?

Yes, it can be done.

No. It isn't as simple as these guys have made it.

It isn't that simple because the structure is broken; a node in a list simply has no business owning itself.

*shrug*

That isn't to say it is really all that difficult.

You need to eliminate the mutual reference; unwind the mutual reference and follow normal procedure.

[Edit]
For those that didn't catch the mutual reference: this destructor drives both `left->~List()' and `right->~List()' to call `this->~List()' which is completely insane as `this' is being destroyed three or four times depending on how nodes (`List' objects) are managed.
[/Edit]

Soma

Originally Posted by iMalc

Hence your destructor has infinite recursion.

It's actually worse than that. The destructor has infinite recursion if the object begin destroyed was created with operator new, and the destructor has been invoked by the corresponding operator delete. Otherwise the code has undefined behaviour (using operator delete on an object that wasn't created with operator new). Practically, it is still infinitely recursive, but it could also cause any conceivable chaos (eg tromping random memory) on each recursive call.

That's just a quibble on my part, as everything you say in your spot is absolutely spot on.

If the original class design can't be changed (bearing in mind that "class design" includes both the interface specification and behavioural specification) then my response would be simple: use another class, even if I have to roll my own.

Thank you so much for you guys.
Does it mean I need to modify the destructor code?? Or deletion cannot be done by destructor and I have to implement a function to do so.

Originally Posted by kobe

Does it mean I need to modify the destructor code?? Or deletion cannot be done by destructor and I have to implement a function to do so.

You need to modify the "destructor code". A destructor is a function (albeit a special one) and, like any function, can do deletion.

The thing is, the destructor is invoked as part of the process of destroying the object. If the destructor is invoked to as part of the process of destroying object X, it should not attempt to initiate destruction of object X. But that is exactly what "delete this" does. The effect is we are destroying X, so delete X, which starts destroying X, which deletes X, which starts destroying X ..... i.e. infinite looping or recursion.

The other thing is that operator delete has no effect on a NULL pointer - the C++ standard guarantees that. A destructor will never be invoked with this being a NULL pointer either (unless some other code has invoked undefined behaviour, in which case all bets are off). So your various comparisons with NULL are pointless.

The other thing to realise is that operator delete should not be used on a pointer, unless that pointer came from operator new (and, since there are multiple forms of operator new and delete, the versions also need to line up).