Создать класс итератора для односвязного списка

#include <iostream>
using namespace std;
 
template <typename T>
class ListIterator;                     /* предварительное объявление класса итератора */
 
template <typename T>                   /* класс должен быть шаблонным */
class List
{
protected:
    friend ListIterator<T>;
    template <typename T>               /* шаблон */
    class Node                          /* вложенный класс (Node - узел) */
    {
    public:                             /* здесь уже все поля можно сделать public к, т.к. сам класс private */
        Node* pNext;                    /* (pNext - pointer Next) - указатель на следующий элемент */
        T data;
        Node(T data = T(), Node* pNext = nullptr) /* конструктор для класса "Узел". nullptr - нулевой адрес*/
        {
            this->data = data;
            this->pNext = pNext;
        }
    };
 
public:
    typedef ListIterator<T> Iterator;   /* Iterator - псевдоним */
    List();                             /* конструктор */
    ~List();                            /* деструктор */
    void pop_front();                   /* прототип метода. Его задача - удалить первый элемент списка */
    void push_back(T data);             /* прототип метода. Push_back - добавить данные в конец списка */
    void clear();                       /* метод просто удаляет все элементы из списка */
    T& operator[](int index);           /* перегрузка оператора. В параметрах - индекс (номер элемента) */
    //void print();                     /* метод выводит значения в списке */
 
private:
    int Size;                           /* кол-во элементов в списке */
    Node<T>* head; /* указатель, так как все элементы одн. списка выделяются в динамич. памяти */
 
public:
    List& operator ++ ()
    {
        head = head->pNext;
        return *this;
    }
};
 
template<class T>
class ListIterator /* реализация класса итератора */
{
public:
    ListIterator(/* какие-то параметры */) {/* какая-то реализация */ }
 
};
 
template<typename T>
List<T>::List() /* конструктор */
{
    Size = 0;
    head = nullptr; /* список пуст */
}
 
template <typename T>
List<T>::~List() /* реализация деструктора */
{
    cout << "Вызвался деструктор" << endl;
    clear();
}
 
template<typename T>
void List<T>::clear() /* метод просто удаляет все элементы из списка */
{
    while (Size) /* Size > 0, while == TRUE, Size = 0, while == FALSE (выход из цикла, если FALSE) */
    {
        pop_front(); /* удаление с первого элемента */
    }
}
 
template<typename T>
void List<T>::pop_front() /* метод удаляет первый элемент списка */
{
    Node* temp = head; /* temp - временная переменная, хранящая адрес нулевого элемента списка */
    head = head->pNext;   /* в head запишем адрес следующего элемента, который идёт за head'ом */
    delete temp;          /* temp указывает на те данные, которые были нашим head'ом */
    Size--;     /* так как мы удалили один из элементов, число элементов надо понизить на 1 */
}
 
template<typename T>
void List<T>::push_back(T data) /* к слову, мне программа помогла реализовать этот метод*/
{
    if (head == nullptr) /* проверяем на равенство head на ноль */
    {
        head = new Node<T>(data);
    }
    else
    {
        Node* current = this->head; /* current (текущий) - временный объект*/
        while (current->pNext != nullptr)
        {
            current = current->pNext;
        }
        current->pNext = new Node<T>(data);
    }
    Size++;
}
 
template<typename T>
T& List<T>::operator[](const int index)
{
    int counter = 0;
    Node* current = this->head; /* current отвечает за нахождение в конкретном элементе */
    while (current != nullptr)     /* цикл работает до тех пор, пока current не станет указывать на ноль */
    {
        if (counter == index)      /* если ноль - мы в конце списка */
        {
            return current->data;  /* у текущего элемента заберём данные из поля data */
        }
        current = current->pNext;
        counter++;
    }
}
 
template <class T>
ostream& operator << (ostream& os, const List<T>& list) /* перегрузка оператора ostream */
{
    for (typename List<T>::Iterator it = list; !it.end(); ++it)
    {
        os << *it << " ";
    }
    return os;
}
 
int main()
{
    setlocale(LC_ALL, "ru");
 
    List<int> List1;
    cout << "Введите число элементов: ";
    int NumbersCount; /* переменная для числа значений */
    cin >> NumbersCount;
 
    for (int i = 0; i < NumbersCount; i++) /* цикл для заполнения списка элементами */
    {
        cout << "Введите объект " << i + 1 << ": ";
        int number;
        cin >> number;
        List1.push_back(number); /* втыкаем номер в список */
    }
    cout << "List1: " << List1 << endl;
    List<int> List2;
 
    int max = 0, index = 1;
    /*for (List<int>::Iterator it = List1; !it.end(); ++it)
    {
        if (max < *it)
        {
            List2.clear();
            max = *it;
        }
        if (max == *it)
        {
            List2.push_back(index);
        }
        index++;
    }*/
 
    cout << endl;
    cout << "Порядковый(-е) номер(-а) макс. элемента(-ов): " << List2 << endl;
    cout << endl;
    system("pause");
    return 0;
}

class listIterator 
{
private:
const list *collection;
el *cur;
public:
listIterator (const list *s, el *e):collection(s), cur(e){}
/*реализация методов итератора */
}