Ошибка в выделении памяти

template<class T>
class DoubleLinkedList 
{
    struct Element 
    {
        Element* prev;//ссылка на предидущий элемент
        Element* next;//ссылка на следующий элемент
        T content;// содержимое элемента
    };
 
    Element* head;//первый элемент
    Element* tail;//Последний элемент
    size_t size;
 
    
    //Получение элемента списка
    Element* getElement(unsigned int index){
        //TODO check index out of bounds
        Element* result;
        if (index > size / 2) 
        {
            result = tail;
            for (int i = size - 2; i >= index; i--)
            {
                result = result->prev;
            }
        }
        else 
        {
            result = head;
            for (int i = 1; i <= index; ++i)
            {
                result = result->next;
            }
        }
 
        return result;
    }
 
public:
    DoubleLinkedList();
    DoubleLinkedList(const DoubleLinkedList& copy);
    ~DoubleLinkedList();
 
    T get(unsigned int index);
    bool contains(T element);
    bool insert(T element, unsigned int position);
    bool remove(unsigned int index);
    bool remove(T element);
 
    void sort();//сортировка
 
    T* toArray(T* buffer, size_t size);//Преобразование списка в массив
 
    T operator[](unsigned int index);
    DoubleLinkedList operator+(const DoubleLinkedList& list);
    DoubleLinkedList operator-(const DoubleLinkedList& list);
    DoubleLinkedList operator=(const DoubleLinkedList& list);
};
 
 
//Конструктор с параметрами (нулевое значение)
//Размер списка = 0
template<class T>
DoubleLinkedList<T>::DoubleLinkedList() 
{
    this->head = nullptr;
    this->tail = nullptr;
    this->size = 0;
}
 
template<class T>
T DoubleLinkedList<T>::get(unsigned int index) 
{
    return getElement(index)->content;
}
 
template<class T>
bool DoubleLinkedList<T>::contains(T element)
{
    Element* result = head;
    for (int i = 1; i < size; ++i) 
    {
        if (result->content == element) 
        {
            return true;
        }
        result = result->next;
    }
 
    return false;
}
 
//Удаление элемента по индексу
template<class T>
bool DoubleLinkedList<T>::remove(unsigned int index)
{
    Element* current = Element*[index];
 
    Element* next;
    next = current->next;
    delete current;
    current = next;
}
 
//Удаление элемента
template<class T>
bool DoubleLinkedList<T>::remove(T element)
{
    Element* current = Element* T;
 
    Element* next;
    next = current->next;
    delete current;
    current = next;
}
 
 
//Переопределение оператора [] на возвращение индекса содержимого квадратных скобок
template<class T>
T DoubleLinkedList<T>::operator[](unsigned int index)
{
    return this->get(index);
}
 
//Деструктор
//Удаление с первого до последнего (с лева на право) по ссылкам
template<class T>
DoubleLinkedList<T>::~DoubleLinkedList(){
    Element* current = head;
 
    Element* next;
    for (int i = 0; i < size; ++i)
    {
        next = current->next;
        delete current;
        current = next;
    }
}
 
//Вставка в конец списка
template<class T>
bool DoubleLinkedList<T>::insert(T element, unsigned int position) 
{
    Element* newElement = new Element();//увеличение размера списка
    newElement->content = element;
    Element* next = getElement(position);
    Element* prev = nullptr;
    if (next == nullptr) 
    {
        tail = newElement;
    }
    else {
        prev = next->prev;
        next->prev = newElement;
    }
    if (prev == nullptr) 
    {
        head = newElement;
    }
    else {
        prev->next = newElement;
    }
 
    newElement->next = next;
    newElement->prev = prev;
    ++size;
    return true;
}
 
//преобразование списка в массив
template<class T>
T* DoubleLinkedList<T>::toArray(T* buffer, size_t size)
{
    Element* current = head;
    int mass[size];
    for (int i = 0; i < size; i++)
    {
        mass[i] = current;
        current = current->next;
    }
 
}
 
//сортировка
template<class T>
void DoubleLinkedList<T>::sort()
{
    Element *current = head;
    while (current->next)
    {
        if ((current->content)>(current->next->content))
        {
            //обмен
            int temp = current->next->content;
            current->next->content = current->content;
            current->content = temp;
 
            current = current->next;
            sort();
        }
        else 
        { 
            current = current->next;
        }
    }
}

#include"DoubleLinkedList.h"
#include<iostream>
 
int main()
{
    DoubleLinkedList<int> d;
    //d.insert(5,0);
    d.insert(2, 0);
    d.insert(3, 1);
    d.insert(5, 2);
    d.insert(0, 3);
 
    //std::cout << d.get(0)<<"\n";
 
    d.sort();
 
    for (int i = 0; i < 4; i++)
    {
        std::cout << d.get(i) << "\n";
    }
 
    system("pause");
}