How to avoid a destructor being called twice in C++?

Question

I'm testing out a class representing an dynamic array data structure I made for myself as practice with the language, but I ran into a problem where the destructor is called twice over, causing a heap corruption error.

So far, I have attempted to comment out some of the delete words. However, this leads to undefined behavior.

#include <iostream>
#include "windows.h"
#include <vector>

template<typename T> class Spider {
private:

    T** pointer;

    int maxSize;
    int lengthFilled;
public:
    //default constructor
    Spider()
    {
        pointer = new T * [1];
        maxSize = 1;
        lengthFilled = 0;
    }
    //destructor
    ~Spider()
    {
        for (int i = 0; i < lengthFilled; i++)
        {
            pop();
        }
        delete[] pointer;
    }
    //Pushes an object in
    void push(T thing)
    {
        if (lengthFilled == maxSize)
        {
            increaseSize();
        }

        T* thinggummy = &thing;

        //then save its pointer in the functional array
        pointer[lengthFilled] = thinggummy;
        lengthFilled++;
    }

    //pops the array
    void pop()
    {
        delete pointer[lengthFilled-1];
        setSize(lengthFilled - 1);
        lengthFilled--;
    }
}

int main()
{

    Spider<Spider<int>> test((long long)1);

    for (int i = 0; i < 2; i++)
    {
        test.push(Spider<int>());
        test.get(i).push(2);//this is implemented in the actual code, just omitted here
        std::cout << test.get(i).get(0);
        std::cout << "push complete\n";
    }

    system("pause");

    return 0;
}

The expected results for this program should be:

2
push complete
2
push complete

Press any key to continue...

Instead, I get an critical error code in the debug log of "Critical error detected c0000374".

@πάνταῥεῖ - No, not that one. A wrong duplicate is worse than a just duplicate remaining wrongfully open — StoryTeller - Unslander Monica, May 28 '19 at 06:23
@πάνταῥεῖ - It doesn't. The OP is taking the address of a local and storing it. They haven't hit the rule of 3 yet. — StoryTeller - Unslander Monica, May 28 '19 at 06:24
`T* thinggummy = &thing` . You are taking address of a stack variable and will be gone as soon as your `push` will complete its execution. And there might happen a *kaboom!!* as soon as you'll dereference `thinggummy` — WhiteSword, May 28 '19 at 06:30
@WhiteSword - You should post answers in the (now reopened) answer section. — StoryTeller - Unslander Monica, May 28 '19 at 06:32
@XnossisX How is your code even compiling? I suppose you've tried to provide the minimalist code, with syntax and other errors, right? — WhiteSword, May 28 '19 at 07:45
Yes, I provided the version of the code that was the only part necessary for finding the issue. — XnossisX, May 30 '19 at 06:34

score 2 · Accepted Answer · answered May 28 '19 at 06:43

2

There are two issues here:

Like WhiteSword already mentioned, you are taking the address of a local variable when you do T *thinggummy = &thing. That is going to cause trouble since that address will be invalid as soon as you leave scope (unless maybe T resolves to a reference type).
You call delete on the things in the pointer array. However, these were not allocated via new. Instead they are just addresses of something. So you are trying to free something that was never allocted.

answered May 28 '19 at 06:43

Daniel Junglas

5,830
1
5
22

Thanks! Would I need to create a new T in the heap, and then deep copy the contents of thing over? – XnossisX May 28 '19 at 06:55
What to do depends on what type `T` actually is and/or for which types this `Spider` class should work. For example, if `T` is a primitive type then there is no need to allocate/deallocate anything. If `T` is a pointer then maybe it is ok to just store the pointer, maybe you want a deep copy. In general you probably want to rely on the copy constructor and assignment operators of `T` to do the right thing. You may want to check some template tutorials/courses. These sort of things are usually explained in depth there. – Daniel Junglas May 28 '19 at 07:05

How to avoid a destructor being called twice in C++?

1 Answers1