Destructor in template class gives an error

user_9172668 0
Viewed 81

I have an Array template class which looks like this

template <typename T>

class Array {
   private:
    T *_array;
    int _arrSize;

   public:
    Array<T>() : _arrSize(0) {
        T *a = new T[0];
        this->_array = a;
    };

    Array<T>(unsigned int n) : _arrSize(n) {
        T *a = new T[n];
        this->_array = a;
    };

    Array<T>(Array<T> const &copy) : _array(copy._array), _arrSize(copy._arrSize) {
        *this = copy;
        return;
    };

    template <typename G>
    Array<T> &operator=(Array<G> const &rhs) {
        if (&rhs != this) {
            Array<T> tmp(rhs);
            std::swap(*this, tmp);
        }
        return *this;
    };

    ~Array<T>() {
        delete[] this->_array;
        this->_array = NULL;
    };

    T &getArray() const {
        return this->_array;
    }

Which works fine until I try to do the assignment

Array<int> g;
Array<int> i(3);
i[1] = 99;
g = i;

then I get an error 

array(99457,0x10f5f25c0) malloc: *** error for object 0x7fc390c02aa0: pointer being freed was not allocated
array(99457,0x10f5f25c0) malloc: *** set a breakpoint in malloc_error_break to debug
zsh: abort      ./array

which obviously comes from the destructor here

delete[] this->_array;

I'm not sure how to write the assignment operator correctly to avoid this error.

templates c++
1 Answers

how do I work around that, I'm blank as to how to procceed

As mentioned in the comments already: you need a deep copy.

Array(Array const& copy) : _array(new T[copy._arrSize]), _arrSize(copy._arrSize)
// create a NEW array here:           ^
{
    //now you need to copy the data:
    std::copy(copy._array, copy._array + _arrSize, _array);
    // or implement a loop, if you are not allowed to use std::copy
};

You might additionally implement move semantics:

Array(Array&& other)    : _array(other._array), _arrSize(other._arrSize)
// now this object 'steals' the data  ^
{
    // now this is the owner of the data – but you still need to make sure that
    // the data is not owned TWICE, so:
    other._array = nullptr; // I'd prefer this over an empty array – but you should
                            // adjust the other constructor then as well
                            // side note: you CAN safely delete a nullptr, so no
                            // special handling in destructor necessary
    other.arrSize = 0;
};

Actually, you can have it a bit simpler:

Array(Array&& other)    : Array()
// constructor delegation  ^
// (creates an EMPTY Array)
{
    // and now you can just:
    std::swap(*this, other)
};

Another variant (thanks, JeJo, for the hint):

Array(Array&& other)
    : _array(std::exchange(other._array, nullptr)),
      _arrSize(std::exchange(other._arrSize, 0))
{ };
user_13123820
Related