删除动态分配的数组时出错

这门课是期中作业。它是一个动态数组，工作原理类似于矢量。问题是，当一个新索引被添加到数组中时，析构函数被调用（当程序结束时），程序会抛出异常并进入一个名为 dgbheap.c 的文件。当我仅在析构函数中删除原点时，就会发生这种情况。

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 allocationn";
            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

主.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;
    }