error deleting a dynamically allocated array

Question

This class is for a midterm assignment. It's a dynamic array that works like a vector. The problem is that when a new index is added to the array then the destructor is called(when the program ends) the program throws an exception and takes to a file called dgbheap.c. it happens when I delete origin only in the destructor.

DynamicArray.h

    #ifndef DYNAMICARRAY_H
#define DYNAMICARRAY_H
    #include <new>
    #include <cstdlib>
    using namespace std;

    template <class T>
    class DynamicArray
    {
        private:
            T *origin;
            T *allocator;
            int size;
            int current;


        public:
            DynamicArray();
            DynamicArray(int);
            DynamicArray(const DynamicArray&);
            ~DynamicArray();
            void add(int);
            void empty();
            void remove(int);
            int getSize();
            T &operator[](const int&);
            const T operator=(const DynamicArray&);
            void put(T&);
            void put(T);
    };
    template <class T>
    DynamicArray<T>::DynamicArray()
    {
        origin = new T[5];
        allocator = NULL;
        size = 5;
        current = 0;
    }

    template <class T>
    DynamicArray<T>::DynamicArray(int s)
    {
        size = s;

        try
        {
            origin = new T[s];
            allocator = NULL;
            current = 0;
        }
        catch(bad_alloc)
        {
            cout << "Error: Bad memery allocation\n";
            exit(EXIT_FAILURE);
        }
    }

    template <class T>
    DynamicArray<T>::DynamicArray(const DynamicArray& obj)
    {
        empty();
        for(int counter = 0; counter < obj.size - 1; counter++)
        {
            origin[counter] = obj.origin[counter];
        }
    }

    template <class T>
    DynamicArray<T>::~DynamicArray()
    {
        delete [] origin;
        delete [] allocator;
    }

    template <class T>
    void DynamicArray<T>::add(int size)
    {
        allocator = new T[size];
        for(int counter = 0; counter < this-> size - 1; counter++)
        {
            allocator[counter] = origin[counter];
        }
        delete [] origin;
        origin = new T[size];
        this->size = this->size + size;

        for(int counter = 0; counter < this->size - 1; counter++)
        {
            origin[counter] = allocator[counter];
        }
        allocator = NULL;
    }


    template <class T>
    void DynamicArray<T>::empty()
    {
        if(size >= 0)
            delete [] origin;
    }




    template <class T>
    int DynamicArray<T>::getSize()
    {
        return size;
    }

    template <class T>
    T &DynamicArray<T>::operator[](const int &index)
    {
        return origin[index];
    }


    template <class T>
    const T DynamicArray<T>::operator=(const DynamicArray &obj)
    {
        size = obj.size;
        delete [] origin;

        origin = new T[size];

        for(int counter = 0; counter < size; counter++)
            *(origin + counter) = *(obj.origin + counter);

        return *origin;
    }

    template <class T>
    void DynamicArray<T>::put(T &obj)
    {
        if(current == size - 1)
        {

            add(1);
            origin[size - 1] = obj;
            ++current; 
        }
        else
        {
            origin[current] = obj;
            ++current;
        }
    }

    template <class T>
    void DynamicArray<T>::put(T obj)
    {
        if(current > size - 1)
        {

            add(1);
            origin[size - 1] = obj;
            ++current; 
        }
        else
        {
            origin[current] = obj;
            ++current;
        }
    }


    template <class T>
    void DynamicArray<T>::remove(int location)
    {
        allocator = new T[size - 1];
        int skipper = 0;

        for(int counter = 0; counter < size - 1; counter++, skipper++)
        {
            if(counter != location)
                allocator[counter] = origin[skipper]
            else if(counter == location)
            {
                ++skipper;
                allocator[counter] = origin[skipper]
                continue;
            }
        }
    }


    #endif // !DYNAMICARRAY_H

main.cpp

    #include <iostream>
    #include <string>
    #include "DynamicArray.h"

    using namespace std;

    int main()
    {
        DynamicArray<int> a(5);
        a.put(21);
        a.put(22);
        a.put(30);
        a.put(58);
        a.put(87);
        a.put(87);

        cout << a[0] << endl;
        cout << a[1] << endl;
        cout << a[2] << endl;
        cout << a.getSize() << endl;

        system("pause");
        return 0;
    }

Answer 1

The problem is in:

template void DynamicArray::add(int size);

You're confusing your size variables that have same name this->size and argument size

Here's the corrected member function:

template <class T>
void DynamicArray<T>::add(int size)
{
  allocator = new T[this->size]; // was just 'size', needs to be old size
  for(int counter = 0; counter < this->size - 1; counter++)
  {
    allocator[counter] = origin[counter];
  }
  delete [] origin;
  this->size = this->size + size; // was down one line
  origin = new T[this->size]; // was 'size'. ie old size, not new size set in line above

  for(int counter = 0; counter < this->size - 1; counter++)
  {
    origin[counter] = allocator[counter];
  }
  allocator = NULL;
}

Answer 2

Your copy constructor isn't initializing origin. It should be something like this:

template <class T>
DynamicArray<T>::DynamicArray(const DynamicArray& obj)
  : origin(new T[obj.size]),
    size(obj.size),
    allocator(NULL),
    current(obj.current)
{
    for(int counter = 0; counter < obj.size; counter++)
    {
        origin[counter] = obj.origin[counter];
    }
}

Also be careful with your empty() method:

template <class T>
void DynamicArray<T>::empty()
{
    delete [] origin;
    origin = NULL;
    size = 0;
}