Итератор в двухсвязном списке

#ifndef STUDLIST_INCLUDE
#define STUDLIST_INCLUDE
 
template <class INF> class List
{
    friend class Iterator<INF, List<INF> >;
 
    template <class ElemType> struct Elem
    {
        ElemType Inf;
        Elem *Next;
        Elem *Prev;
    };
 
    typedef Elem<INF> ListElem;
 
//~~~~~~~~~~~~~~~~~~~~~Недоступные пользователю методы~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
protected:
 
    ListElem *Head, *CurPos;
 
//~~~~~~~~~~~~~~~~~~~~~Добавление элемента после заданного~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
    void InsertAfter(ListElem *After, INF& Inf)
    {
        ListElem *cur;
 
        if (After)
        {
            cur = new Elem;
            cur->Inf = Inf;
            cur->Prev = After;
            After->Next->Prev = cur;
            cur->Next = After->Next;
            After->Next = cur;
        }
        else
            AddAfterTail(Inf);
    }
 
//~~~~~~~~~~~~~~~~~~~~~~Добавление элемента перед заданным~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
    void InsertBefore(ListElem *Before, INF &Inf)
    {
        ListElem *cur;
 
        if (Before)
        {
            cur = new Elem;
            cur->Inf = Inf;
            cur->Next = Before;
            cur->Prev = Before->Prev;
            Before->Prev->Next = cur;
            Before->Prev = cur;
        }
        else
            AddAfterTail(Inf);
    }
 
//~~~~~~~~~~~~~~~~~~~~~~Удаление элемента из списка~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
    int DeleteElem(INF& Inf)
    {
        if (SearchElem(Inf))
        {
            if (CurPos == cur)
                CurPos = CurPos->Next;
 
            cur->Prev->Next = cur->Next;
            cur->Next-<Prev = cur->Prev;
 
            if (cur == Head)
            {
                Head = Head->Next;
 
                if (cur == Head)
                    CurPos = Head = 0;
            }
 
            delete cur;
        }
        else
            return NOT_SUCCESS_OPERATION;
    }
 
//~~~~~~~~~~~~~~~~~~~~~~Удаление списка~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
    void DeleteList()
    {
        ListElem* cur;
 
        if (Head)
            Head->Prev->Next = 0;
 
        while (Head != 0)
        {
            cur = Head;
            Head = Head->Next;
            delete cur;
        }
 
        Head = CurPos = 0;
    }
 
//~~~~~~~~~~~~~~~~~~~~~~Дбавление элемента в отсортированный список~~~~~~~~~~~~~~~~~~~~~~~~~
 
    void AddIfSorted(INF& Inf)
    {
        ListElem* InsPos;
        ListElem* cur = new Elem;
        cur->Inf = Inf;
 
        if (Head)
        {
            InsPos = Head;
 
            do
            {
                
                if (Cur->Inf > InsPos->Inf)
                    InsPos = InsPos->Next;
 
            }while (InsPos != head)
 
            InsPos->Prev->Next = cur;
            cur->Prev = InsPos->Prev;
            InsPos->Prev = cur;
            cur->Next = InsPos;
        }
        else
        {
            Head = cur;
            CurPos = Head;
        }
    }
 
//~~~~~~~~~~~~~~~~~~~~~~Сортировка списка методов вставки~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
    void Sort()
    {
        ListElem *SortCur, *UnsortCur, *SaveCur;
 
        if ((Head) && (Head->Next != Head))
        {
            UnsortCur = Head->Next;
            SortCur = Head;
            SaveCur = UnsortCur;
 
            do
            {
                
                while (UnsortCur->Inf < SortCur->Inf)
                {
                    SortCur = SortCur->Prev;
 
                    if (SortCur == Head->Prev)
                    {
                        Head = UnsortCur;
                        break;
                    }
 
                }
 
                if (SortCur->Next == UnsortCur->Next)
                {
                    SortCur = UnsortCur;
                    SaveCur = SaveCur->Next;
                    UnsortCur = SaveCur;
                }
 
                    UnsortCur->Prev->Next = UnsortCur->Next;
                    UnsortCur->Next->Prev = UnsortCur->Prev;
                    UnsortCur->Prev = SortCur;
                    UnsortCur->Next = SortCur->Next;
                    SortCur->Next->Prev = UnsortCur;
                    SortCur->Next = UnsortCur;
 
                    SortCur = UnsortCur;
                    SaveCur = SaveCur->Next;
                    UnsortCur = SaveCur;
 
            }while (Unsort != Head)
        }
    }
//~~~~~~~~~~~~~~~~~~~~~~Доступные пользователю методы~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
public:
 
    typedef Iterator<INF, List<INF> > IteratorList;
 
    List()
    {
        Head = CurPos = 0;
    }
 
    ~List()
    {
        DeleteList();
    }
 
    List(List &List)
    {
        *this = List;
    }
 
//~~~~~~~~~~~~~~~~~~~~~~Добавление в конец~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
    void AddAfterTail(INF& Inf)
    {
        ListElem *cur = new ListElem;
        cur->Inf = Inf;
 
        if (Head)
        {
            Head->Prev->Next = cur;
            cur->Prev = Head->Prev;
        }
        else
            Head = cur;
 
        Head->Prev = cur;
        cur->Next = Head;
        cout << "Элемент добавлен \n";
    }
 
//~~~~~~~~~~~~~~~~~~~~~~Поиск элемента в списке~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
    ListElem* SearchElem(INF& Inf)
    {
        bool flag;
        ListElem* cur;
 
        if (Head)
        {
            flag = false;
            cur = Head;
            do
            {
 
                if (cur->Inf == Inf)
                    flag = true;
                else
                    cur = cur->Next;
            }while (cur != Head);
            if (flag)
                return CurPos;
            else
                cur = 0;
        }
        return cur;
    }
 
//~~~~~~~~~~~~~~~~~~~~~~Добавление элемента после заданного~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
    void AddElemAfter(INF& Inf, INF& InfAfter)
    {
        InsertAfter(SearchElem(InfAfter), (INF&)Inf);
    }
 
//~~~~~~~~~~~~~~~~~~~~~~Добавление элемента перед заданным~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
    void AddElemBefore(INF& Inf, INF& InfBefore)
    {
        InsertBefore(SearchElem(InfBefore), (INF&)Inf);
    }
 
 
//~~~~~~~~~~~~~~~~~~~~~~Добавление в отсортированный список~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
    void InsIfSorted(INF& Inf)
    {
        AddIfSorted(INF% Inf);
    }
 
//~~~~~~~~~~~~~~~~~~~~~~Удаление элемента~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
    void DelElem(INF& Inf)
    {
        int DeleteElem(INF& Inf);
        cout << "Элемент удален \n";
    }
 
    
//~~~~~~~~~~~~~~~~~~~~~~Удаление списка~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
    void DestroyList()
    {
        void DeleteList();
    }
 
//~~~~~~~~~~~~~~~~~~~~~~Сортировка~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    void InsertSort()
    {
        void Sort();
    }
};
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//~~~~~~~~~~~~~~~~~~~~~~Iterator~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
template <class INF, class LISTTYPE> class Iterator
{
    typename LISTTYPE::ListElem **Head, *CurPos;
 
    public:
 
        Iterator()
        {
            CurPos = 0;
            Head = 0;
        }
 
        Iterator(Iterator& It)
        {
            *this = It;
        }
 
        Iterator(LISTTYPE& List)
        {
            *this = List;
        }
 
//---------------------------------------------------
 
        Iterator& operator = (Iterator &It)
        {
            Head = It.Head;
            CurPos = It.CurPos;
            return *this;
        }
 
        Iterator& operator = (LISTTYPE &List)
        {
            Head = &(List.Head);
            CurPos = List.Head;
            return *this;
        }
        
        Iterator& operator = (INF &Val)
        {
            if (CurPos)
                CurPos->Inf = Val;
 
            return *this;
        }
 
//---------------------------------------------------
 
        Iterator& operator ++()
        {
            if (CurPos)
                CurPos = CurPos->Next;
 
            return *this;
        }
 
//---------------------------------------------------
 
        bool operator !()
        {
            return CurPos != 0;
        }
 
        bool operator == (INF Val)
        {
            return CurPos ? CurPos->Inf == Val : false;
        }
 
//---------------------------------------------------
 
        void SetStart()
        {
            CurPos = Head ? *Head : 0;
        }
 
        bool IsNotEmpty()
        {
            return Head ? (*Head != 0) : 0;
        }
 
        bool IsHead()
        {
            return CurPos == *Head ? true : false;
        }
 
//---------------------------------------------------
 
        bool GetCurInf(INF &Inf)
        {
            if (CurPos)
            {
                Inf = CurPos->Inf;
                return true;
            }
            return false;
        }
 
        bool GetCurInf(INF *&Inf)
        {
            if (CurPos)
            {
                Inf = &(CurPos->Inf);
                return true;
            }
            return false;
        }
 
};
 
#endif

#include "studlist.h"
#include <iostream>
 
using namespace std;
 
int main()
{
    setlocale(LC_ALL, "rus");
 
    List<int> A;
    Iterator<int,List<int> > It;
    It = A;
    int num;
    int input;
 
    do
    {
        cout << "\nПанель управления двусвязным кольцевым списком \n";
        cout << "1 - Добавить элемент \n";
        cout << "2 - Удалить элемент \n";
        cout << "3 - Найти элемент \n";
        cout << "4 - Вывести на экран полную информацию о найденном элементе \n";
        cout << "5 - Удалить все элементы \n";
        cout << "6 - Вывести на экран полную информацию обо всех элементах \n";
        cout << "7 - Отсортировать элементы \n";
            
        cout << "Выберите действие: ";
        cin >> input;
 
        switch (input)
        {
            case 1:
                
                cout << "Введите элемент: ";
                cin >> num;
                A.AddAfterTail(num);
                break;
 
            case 2:
 
                cout << "Введите элемент: ";
                cin >> num;
                A.DelElem(num);
                break;
 
            case 3:
 
                cout << "Введите элемент: ";
                cin >> num;
 
                if (A.SearchElem(num))
                cout << "Элемент найден \n";
                else
                    cout << "Элемент не найден \n";
                break;
 
            case 4:
 
                cout << "Введите элемент: ";
                cin >> num;
                if (It.IsNotEmpty())
                {
                    It.SetStart();
                    if (It.GetCurInf(num))
                        cout << num;
                    else
                        ++It;
                }
                
                break;
 
            case 5:
 
                A.DestroyList();
                cout << "Удалено \n";
                break;
 
            case 6:
 
                if (It.IsNotEmpty())
                {
                    It.SetStart();
                    do
                    {
                        if (It.GetCurInf(num))
                        {
                            cout << num;
                            ++It;
                        }
                    }
                    while (It.IsHead());
                }
                break;
 
            case 7:
 
                A.InsertSort();
                break;
            default: continue;
        }
 
    }while ((input >= 1) && (input <= 7));
 
    return 0;
}