Field variable deleted before actual destructor called?

Question

What would make a field variable become obsolete before entering the destructor upon deletion of the object? I was a looking for an answer for this problem I'm having on this site and came across this: Lifetime of object is over before destructor is called?

Something doesn't add up at all: if I've declared a pointer to SomeClass inside another WrapperClass, when I construct the WrapperClass I need to create a new SomeClass and delete it on destruction of the wrapper. That makes sense and has worked so far. The pointer is still valid and correct well into the destructor otherwise obviously I wouldn't be able to delete it.

Now my problem is that my field members (both an int and a pointer to a SomeClass array) of WrapperClass are garbage when I call the destructor. I've checked the wrapper object just after construction and the data is fine. The wrapper is actually a pointer in another Main class and the problem occurs when I destruct that Main (which destructs the wrapper) but works fine if I just delete the wrapper from another method in Main. My paranoia led me to the above mentioned answer and now I'm totally confused. Anybody care to shed some light on what's really going on here?

EDIT: Node is the SomeClass.

class WrapperException{};
class Wrapper {
private:
    struct Node { /*....*/ };
    int numNodes;
    Node** nodes;
public:
    Wrapper() : numNodes(0) { nodes = new Node*[SIZE]; }
    Wrapper(const Wrapper& other) { throw WrapperException(); }
    Wrapper& operator=(const Wrapper& other) { throw WrapperException(); }
    ~Wrapper() { //calling delete Main gets me here with garbage for numNodes and nodes
        for(int i = 0; i < numNodes; i++)
            delete nodes[i];
        delete nodes;
    }
};

class MainException{};
class Main {
public:
    Main() { wrapper = new Wrapper(); }
    Main(const Main& other) { throw MainException(); }
    Main& operator=(const Main& other) { throw MainException(); }
    ~Main() { delete wrapper; }
private:
    Wrapper* wrapper;
};

Answer 1

You need to use the Standard library to implement this behaviour.

class Wrapper {
private:
    struct Node { /*....*/ };
    int numNodes;
    std::vector<std::unique_ptr<Node>> nodes;
public:
    Wrapper() : numNodes(0) { nodes.resize(SIZE); }
    // No explicit destructor required
    // Correct copy semantics also implemented automatically
};

class Main {
public:
    Main() : wrapper(new Wrapper()) {}
    // Again, no explicit destructor required 
    // Copying banned for move-only class, so compiler tells you
    // if you try to copy it when you can't.
private:
    std::unique_ptr<Wrapper> wrapper;
};

This code is guaranteed to execute correctly. When in C++, if you have used new[], delete or delete[], then immediately refactor your code to remove them, and review three times any use of non-placement new- constructing a unique_ptr is pretty much the only valid case. This is nothing but a common, expected outcome of manual memory management.

Answer 2

Since Grizzly isn't answering, I'll put this out there.

Both your Main class and your Wrapper class need properly implemented copy constructors and assignment operators. See The Rule of 3.

The problem is, if your class ever gets copied(which is easy to happen without you even realizing it), then the pointers get copied. Now you've got two objects pointing to the same place. When one of them goes out of scope, it's destructor gets called, which calls delete on that pointer, and the pointed to object gets destroyed. Then the other object is left with a dangling pointer. When it gets destroyed, it tries to call delete again on that pointer.

Answer 3

The lifetime of your wrapper object has ended, but the integer and pointer sub-objects as well as the pointee are still alive. When you invoke delete on the pointer, the pointee's lifetime ends, but the pointer still remains alive. The pointer's lifetime ends after your dtor is complete.

Thus, if your members have become corrupted, there is something else afoot.

Answer 4

Node** nodes;

should be

Node * nodes;

Also the destructor is wrong. It should be:

for(int i = 0; i < numNodes; i++)
    delete nodes[i];
delete [] nodes;

There might be other problems as well as e.g. you haven't created a copy constructor or assignment operator so that might make it so that the copy of an object then deletes the object for you.

EDIT: changed the destructor...