Оцените реализацию шаблонного класса Списка

template <class T>
class my_list
{
private:
    struct ListItem  
    {
        T* content;     // данные, хранящиеся в элементе списка
        ListItem* next;
        ListItem* prev;
 
        ListItem()
        {
            next = NULL;
            prev = NULL;
            content = NULL;
        }
 
        /*~ListItem()
        {
            if (content != NULL)
                delete content;
        }*/     // почему-то этот деструтор работает с ошибкой
    }; 
    ListItem* Item;  // собственно, сам элемент списка
    ListItem* first;
    ListItem* last;
 
    void _Insert_After(ListItem *Left, T *NewElement )
    {// вставка нового Item (с содержимым NewElement) после Left
        ListItem *temp = new ListItem;
        temp->content = NewElement;
 
        if (Left != NULL)    // есть ли у нового предыдущий элемент?
        {
            temp->next = Left->next;
            Left->next = temp;
            temp->prev = Left;
            if (temp->next != NULL)
            {
                ListItem *Right = temp->next;
                Right->prev = temp;
            }
            else
            {
                last = temp;
            }
        }
        else  // если новый элемент надо вставить первым
        {
            if (first != NULL)  // если известен первый элемент
            {
                temp->next = first;
                first->prev = temp;
                first = temp;
            }
            else // создали первый элемент. Он же последний
            {
                first = temp;
                last = temp;
            }            
        }
    }
    bool _Set_by_Index( int i )
    {// устанавливает текущим элемент с индексом i, если удачно - возвращает true
        if (i < 0)
        {
            printf ("\n\n***** Элемента с таким индексом нет *****\n");
            return false;
        }
 
        int n = 0; // счетчик пройденных от начала списка
        ListItem *cur = first;
        while (i != n && cur != NULL)
        {
            cur = cur->next;
            n++;
        }
        
        if (cur)
        {
            Item = cur;
            return true;
        }
        else
        {
            printf ("\n\n***** Элемента с таким индексом нет *****\n");
            return false;
        }
    }
    void _Swap_Items (ListItem* item_1, ListItem* item_2)
    {// менят местами 2 Item'a 
        ListItem* left_1 = item_1->prev;
        ListItem* right_1 = item_1->next;
        ListItem* left_2 = item_2->prev;
        ListItem* right_2 = item_2->next;
 
        if (left_1 != NULL)
            left_1->next = item_2;
 
        if (right_1 != NULL)
            right_1->prev = item_2;
 
        if (left_2 != NULL)
            left_2->next = item_1;
 
        if (right_2 != NULL)
            right_2->prev = item_1;
 
        ListItem* temp;
 
        temp = item_1->next;
        item_1->next = item_2->next;     // обменяли местами item_1.next и item_2.next
        item_2->next = temp;
 
        temp = item_1->prev;
        item_1->prev = item_2->prev;      // обменяли местами item_1.prev и item_2.prev
        item_2->prev = temp;
 
        if (item_1->prev == NULL) first = item_1;
        if (item_2->prev == NULL) first = item_2;
        if (item_1->next == NULL) last = item_1;
        if (item_2->next == NULL) last = item_2;
    }
    void _Delete_Item (ListItem* del)
    {// удаляет один Item
        ListItem *Right = del->next;
        ListItem *Left = del->prev;
 
        if (Right != NULL)
            Right->prev = del->prev;
 
        if (Left != NULL)
            Left->next = del->next;
 
        del->next = NULL;
        del->prev = NULL;
 
        if (first == del)
            first = Right;
 
        if (last == del)
            last = Left;
 
        delete del->content;
        
        delete del; 
 
        del = NULL;
    }
    void _mkCopy (my_list &cpyfrm)
    {// изначально это был конструтор копии
        // это конструктор копии
        // используется, например, при передаче/возвращении объекта функцией
        // создается полная копия списка
        // соответственно, тратится время и память
        // чтобы этого не происходило, нужно передавать объект по ссылке
        T* cur = NULL;
        first = NULL;
        last = NULL;
        for (cur = cpyfrm.Get_First(); cur; cur = cpyfrm.Get_Next() )
        {
            // я долго думал, как сделать конструктор копии
            // ведь если content копии будет ссылаться ту да же, куда и оригинал,
            // то при разрушении копии   content оригинала разрушится
            // была мысль использовать *content = *cur
            // но тогда, если в content'e содержатся указатели на что-либо, то
            // просто скопируется указатель и опять плохо
            // поэтому при создании копии используется конструктор копии типа T
            // (если он, конечно, есть, а если нет - то побитовая копия)
            T* content = new T ( *cur);
            Push_Back( content);
        }
    }
//
public:
    my_list(void)   { first = NULL;  last = NULL; Item = NULL; }
    my_list (my_list &cpyfrm)  { _mkCopy (cpyfrm); }
    ~my_list(void)  {    Clear();   }
    T* Get_Cur()
    {// возвращает содержимое текущего элемента
        if (Item)
        {
            return Item->content;
        }
        else 
            return NULL;
    }
    T* Get_Next ()
    {// устанавливает текущим следующий и возвращает его содержимое
        if (Item)
        {
            if (Item->next == NULL)
                return NULL;
 
            Item = Item->next;
            return Get_Cur();
        }
        else 
            return NULL;
    }
    T* Get_Prev()
    {// устанавливает текущим предыдущий и возвращает его содержимое
        if (Item)
        {
            if (Item->prev == NULL)
                return NULL;
 
            Item = Item->prev;
            return Get_Cur();
        }
        else 
            return NULL;
    }
    T* Get_First ()
    {// устанавливает текущим первый и возвращает его содержимое
        if (first == NULL)
            return NULL;
 
        Item = first;
        return Get_Cur();
    }
    T* Get_Last ()
    {// устанавливает текущим последний и возвращает его содержимое
        if (last == NULL)
            return NULL;
 
        Item = last;
        return Get_Cur();
    }       
    void Push_Back(T *NewElement)
    {// помещает Item с содержимым NewElement в конец списка
        if (NewElement)
            _Insert_After(last, NewElement);    
        else 
            printf ("\n\n***** Невозможно создать пустой элемент списка *****\n\n");
    }
    void Sort ( int (*cmp_func) (T* , T* ), int key)
    {// cmp_func - функция, сравнивающая два элемента списка, key: 1 - по возрастанию, -1 - по убыванию
        ListItem *i = first;
        while (i != NULL)
        {
            ListItem* m = i; // указатель на мин/макс элемент
            ListItem* j = i->next;
            while (j != NULL)
            {
                if ( (*cmp_func) (m->content, j->content) == key ) 
                {
                    m = j;
                }
                j = j->next;
            }
            _Swap_Items(i, m);   // поменяли местами элементы
            i = m->next;        // т.к. поменяли местами i-ый и m-ый элементы, то начало ближе к m-му
        }
    }
    void Do_For_Each ( void (*WtD) (T*) )
    {// сделать с каждым функцию WtD
        ListItem* i = first;
        while (i != NULL)
        {
            WtD (i->content);
            i = i->next;
        }
    }
    bool Delete_by_Index(int i)
    {// удалить i-ый элемент (считая с 0), если не удалось - возвращает false
        if (_Set_by_Index(i) )
        {
            if ( Delete_Cur() )
                return true;
        }
        return false;
    }
    bool Delete_Cur ()
    {// удалить текущий элемент, при этом текущим станет предыдущий, 
     // или первый, или следующий, или список опустеет
        if (Item)
        {
            if (Item->prev)
            {
                Item = Item->prev;
                _Delete_Item (Item->next);
                return true;
            }
            else
                if (Item->next)
                {
                    Item = Item->next;
                    _Delete_Item (Item->prev);
                    return true;
                }
                else
                {
                    _Delete_Item (Item);
                    Item = NULL;
                    return true;
                }
        }
        else
            return false;
    }
    void Clear ()
    {// очищает список
        ListItem* del;
        del = first;
        while (del)
        {
            ListItem* cur = del;
            del = del->next;
            if (cur->content)
                delete cur->content;  // хотел использовать деструктор ListItem, но он работает с ошибкой
            cur->content = NULL;
            cur->next = NULL;
            cur->prev = NULL;
            delete cur;
        }
        first = NULL;
        last = NULL;
    }
    bool Find (T* searching)
    {// устанавливает текущим элемент searching, если такой элемент есть - возвращает true
        if (searching == NULL)
        {
            printf ("\n\n***** Не задан элемент для поиска *****\n\n");
            return false;
        }
        ListItem *cur = first;
        while (cur->content != searching && cur)
        {
            cur = cur->next;
        }
        if (cur->content == searching)
        {
            Item = cur;
            return true;
        }
        else 
        {
            printf ("\n\n***** Искомый элемент не найден *****\n\n");
            return false;
        }  
    }
    int Length ()
    {// возвращает количество элементов списка
        int l = 0;
        ListItem* cur = first;
        while (cur)
        {
            ++l;
            cur = cur->next;
        }
        return l;
    }
    bool End ()
    {// текущий элемент последний?
        if (Item)
        {
            if (Item->next == NULL)
                return true;
        }
        return false;
    }
    bool Insert_After(T* LeftElement, T* NewContent)
    {// вставляет новый элемент NewContent после элемента LeftElement
     // если удачно - возвращает true
 
        if (Find (LeftElement))
        {
            _Insert_After(Item, NewContent);
        }
        else 
            return false;
    }
    void operator = (my_list<T>& RightHandValue)
    {
        Clear();
        _mkCopy (RightHandValue);
    }
    T* operator [](int i)
    {// устанавливает текущим i-ый элемент и возвращает содержимое
     // этот список можно индексировать, хотя при больших размерах списка неэффективно
        if (_Set_by_Index(i))
            return Item->content;
        else
            return NULL;
    }
};