Error: Выдаёт ошибку C2679 binary "[": не найден оператор, принимающий правый операнд типа "тип"

#include <iostream>
using namespace std;
 
/* оДНОсвязный список */
 
template <typename T> /* класс должен быть шаблонным */
class List
{
    
public:
    List(); /* конструктор */
    ~List(); /* деструктор */
    
    void pop_front();       /* прототип метода. Его задача - удалить первый элемент списка */
    void push_back(T data); /* прототип метода. Push_back - добавить данные в конец списка */
    bool end()
    {
        return(head = NULL);
    }
    void clear();             /* метод просто удаляет все элементы из списка */
    T& operator[](int index); /* перегрузка оператора. В параметрах - индекс (номер элемента) */
    friend ostream& operator<< (ostream& out, const List& list);
    
    
 
    void push_front(T data);        /* метод добавляет элемент в начало списка*/
    void pop_back();                /* удаляет элемент из конца списка */
    void insert(T data, int index); /* вставляет элемент по конкретному индексу */
    
    /* value - данные, index - индекс, по которому эти данные вставлены */
    void removeAt(int index);       /* удаляет элемент из списка по указанному индексу */
 
private:
    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;
        }
    };
 
    int Size; /* кол-во элементов в списке */
    Node <T>* head; /* указатель, так как все элементы одн. списка выделяются в динамич. памяти */
public:
    List& operator ++ ()
    {
        head = head->pNext;
        return *this;
    }
};
 
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>::pop_front()
{
    Node<T>* 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<T>* current = this->head; /*current (текущий) - временный объект*/
        while (current->pNext != nullptr)
        {
            current = current->pNext;
        }
        current->pNext = new Node<T>(data);
    }
    Size++;
}
 
template<typename T>
void List<T>::clear() /* метод просто удаляет все элементы из списка */
{
    while (Size) /*Size > 0, while == TRUE, Size = 0, while == FALSE (выход из цикла, если FALSE)*/
    {
        pop_front();
    }
}
 
template<typename T>
T& List<T>::operator[](int index)
{
    int counter = 0;
    Node<T>* current = this->head; /* current отвечает за нахождение в конкретном элементе */
    while (current != nullptr)     /* цикл работает до тех пор, пока current не станет указывать на ноль */
    {                          
        if (counter == index)      /* если ноль - мы в конце списка */
        {
            return current->data;  /* у текущего элемента заберём данные из поля data */
        }
        current = current->pNext;
        counter++;
    }
}
 
 
template<typename T>
void List<T>::push_front(T data)
{
    head = new Node<T>(data, head); /* переносим "голову" в адрес другого элемента */
    Size++;
}
 
template<typename T>
void List<T>::pop_back() /* удаляем последний элемент списка */
{
    removeAt(Size - 1); /* нумерация начинается с нуля. Допустим у нас элементы с инд. 0,1,2 - всего их три */
} /* чтобы получить доступ к последнему - просто
вычитаем единицу */
 
template<typename T>
void List<T>::insert(T data, int index)
{
    if (index == 0) /* если index = 0 */
    {
        push_front(data);
    }
    else
    {
        Node<T>* previous = this->head; /* previous - временный указатель */
 
        for (int i = 0; i < index - 1; i++) /* цикл находит элемент с индексом, предшествующим (int index) */
        { /* на место которого мы хотим поместить объект */
            previous = previous->pNext; /* "-1" означает "предыдущий", как и слово previous */
        } /*в этом цикле мы просто перебираем элементы, идущие по цепочке в списке*/
 
        Node<T>* newNode = new Node<T>(data, previous->pNext); /* объект указывает на след. объект */
        previous->pNext = newNode; /*помещаем наш новый объект по указанному индексу в список */
        /* newMode переменная по факту и не нужна. Это буфер */
        Size++;
    }
 
 
}
 
template<typename T>
void List<T>::removeAt(int index) /* логика примерно такая же, как и с insert, но ориентирована на удаление */
{
    if (index == 0)
    {
        pop_front();
    }
    else
    {
        Node<T>* previous = this->head; /* задача блока кода со 159-й по 163-й строчки - найти предыдущий элемент */
        for (int i = 0; i < index - 1; i++) /* относительно того, который мы хотим удалить */
        {
            previous = previous->pNext;
        }
 
        Node<T>* toDelete = previous->pNext; /* в toDelete лежит адрес старого элемента */
        previous->pNext = toDelete->pNext; /* в тот старый адрес мы помещаем адрес элемента, который мы хотим удалить*/
        delete toDelete; /* удаляем старый адрес */
        Size--; /* уменьшаем число элементов на единицу */
    }
}
 
template<typename T>
ostream& operator<<(ostream& out, const List<T>& list)
{
    for (List<T> i = list; !i.end(); ++i)
    {
        out << list << endl;
    }
    return out;
}
 
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); /* втыкаем номер в список */
    }
    
    for (int i = 0; i != NumbersCount; i++)
    {
        cout << List1[i] <<" "; /* вывод элементов списка */
    }
    cout << endl;
    
    /* формирование второго списка */
    List<int> List2;
    int max = 0, index = 0;
 
    for (List<int> i = List1; !i.end(); ++i)
    {                       
        if (max <= List1[i]) /* если макс. элемент меньше элемента по индексу i */
        {
            List2.clear();  /* чистим наш список */
            max = List1[i]; /* мы приравниваем макс. элемент к элементу с индексом  */
            index++;
        }
        
        /* MAX ЭЛЕМЕНТ ОН ПРАВИЛЬНО ОПРЕДЕЛИЛ !!! */
        if (max >= List1[i])
        {
            List2.push_back(index); /* вставляем элемент по опред. индексу. */
        }
    }
 
    ///* если будут одинаковые элементы, он выведет не все их индексы, а только последний... */
 
    cout << endl;
    cout << "Наибольший элемент: " << max << " " << endl;
    cout << "Порядковый номер наибольшего элемента: " << index; /* index определён верно! */
    cout << endl;
 
    cout << List2 << endl;
 
    cout << endl;
    system("pause");
    return 0;
}

 for (List1.next(); !List1.end(); List1.next())

#include <iostream>
using namespace std;
 
template <class T>
class List
{
    int Size;
    
    struct Node
    {
        T data;
        Node* next;
        Node(const T& data, Node* next = nullptr) : data{ data }, next{ next } {}
    };
 
    Node* it = nullptr; /* наш псевдо-итератор */
    Node* head = nullptr; /* голова списка (начало) */
    Node* list = nullptr; /* указатель на список */
 
public:
 
    List() :list(NULL) /* горе - конструктор */
    {
        cout << "Вызван конструктор листа" << endl;
        return;
    }
 
    bool begin()
    {
        /*cout << "begin:" << endl;*/
        return (it = head);
    }
    T& get()
    {
        /*cout << "get:" << endl;*/
        return it->data;
    }
    void next()
    {
        /*cout << "next:" << endl;*/
        it = it->next;
    }
    bool end()
    {
        /*cout << "end:" << endl;*/
        return it == nullptr;
    }
    void push_front(const T& data)
    {
        /*cout << "push_front:" << endl;*/
        head = new Node(data, head);
    }
    void push_back(const T& data)
    {
        /*cout << "push_back:" << endl;*/
        if (head == nullptr)
        {
            head = new Node(data);
        }
        else
        {
            Node* current = this->head; /* current - временный */
            while (current->next != nullptr)
            {
                current = current->next;
            }
            current->next = new Node(data);
        }
    }
    T pop_front()
    {
        /*cout << "pop front:" << endl;*/
        Node* head = list; 
        list = list->next;
        T data = head->data;
        return data;
    }
 
    bool empty()
    {
        /*cout << "empty:" << endl;*/
        return (list == NULL);
    }
    void clear()     /* метод просто удаляет все элементы из списка */
    {
        /*cout << "clear:" << endl;*/
        while (empty() == false)
        {
            pop_front();
        }
    }
    List& operator ++ ()
    {
        head = head->next;
        return *this;
    }
    T operator * ()
    {
        return head->data;
    }
};
 
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); /* втыкаем номер в список */
    }
 
    for (List1.begin(); !List1.end(); List1.next())
        cout << List1.get() <<" "; /* вывод элементов списка */
    cout << endl;
    
    /* ФОРМИРОВАНИЕ ВТОРОГО СПИСКА */
    cout << "Формируем второй список" << endl;
    List<int> List2;
    int max = 0, index = 1;
    
 
    for (List<int> it = List1; !it.end(); ++it)
    {
        if (max < *it)
        {
            List2.clear();
            max = *it;
        }
        if (max == *it)
        {
            List2.push_front(index);
        }
        index++;
    }
 
    for (List2.begin(); !List2.end(); List2.next())
        cout << List2.get() << " "; /* вывод элементов списка */
 
    cout << endl;
    return 0;
}

Node * tail.

#include <iostream>
#include <list>
#include <vector>
 
using namespace std;
 
template <class T>
class List
{
    struct Node
    {
        T data;
        Node* next;
        Node(const T& data, Node* next = nullptr) : data { data }, next { next } {}
    };
 
    Node* it = nullptr; /* наш итератор */
    Node* head = nullptr;
    Node* tail = nullptr;
 
public:
    bool begin()
    {
        return (it = head);
    }
    T& get()
    {
        return it->data;
    }
    void next()
    {
        it = it->next;
    }
    bool end()
    {
        return it == nullptr;
    }
    void push_front(const T& data)
    {
        head = new Node(data, head);
    }
    void push_back(const T& data)
    {
        tail = new Node(data, tail);
    }
    T pop_front()
    {
        /*cout << "pop front:" << endl;*/
        Node* head = it;
        it = it->next;
        T data = head->data;
        return data;
    }
 
    bool empty()
    {
        /*cout << "empty:" << endl;*/
        return (it == NULL);
    }
    void clear()     /* метод просто удаляет все элементы из списка */
    {
        /*cout << "clear:" << endl;*/
        while (empty() == false)
        {
            pop_front();
        }
    }
};
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); /* втыкаем номер в список */
    }
 
    for (List1.begin(); !List1.end(); List1.next())
        cout << List1.get() << " "; /* вывод элементов списка */
    cout << endl;
 
    /* ФОРМИРОВАНИЕ ВТОРОГО СПИСКА */
    List<int> List2;
    List1.begin();
    
    if (!List1.end()) 
    {
        int max = List1.get(), i = 1;
        List2.push_front(i);
        ++i;
        for ( List1.next(); !List1.end(); List1.next()) 
        {
            if (List1.get() == max)
                List2.push_front(i);
 
            else if (List1.get() > max) 
            {
                List2.clear();
                max = List1.get();
                List2.push_front(i);
            }
            ++i;
        }
    }
 
    for (List2.begin(); !List2.end(); List2.next())
        cout << List2.get() << " "; /* вывод элементов списка */
    cout << endl;
    return 0;
}

#include <iostream>
 
using namespace std;
template <class T>
class List{
    struct Node{
        T data;
        Node* next;
        Node(const T& data, Node* next = nullptr):data{data}, next{next}{}
    };
    Node* it=nullptr; // наш итератор
    Node* head=nullptr;
    void reset(){
        head = nullptr;
        it = nullptr;
    };
public:
    void clear(){
        Node *h = head;
        Node *tmp;
        while(h){
            tmp = h->next;
            delete h;
            h = tmp;
        }
        reset();
    }
    bool empty(){
        return head == nullptr;
    }
    bool begin(){
        return (it = head);
    }
    T& get(){
        return it->data;
    }
    void next(){
        it = it->next;
    }
    bool end(){
        return it==nullptr;
    }
    void push_front(const T& data){
        head = new Node(data, head);
    }
    void push_after_it(const T& data){
        if (!it)
            begin();
        if (!it){
            head = new Node(data);
            it = head;
            return;
        }
        it->next = new Node(data, it->next);
        next();
    }
    ~List(){
        clear();
    }
};
 
int main()
{
    List<int> l1;
    for(int i=1; i<11; ++i)
       (i%2 != 0) ? l1.push_after_it(i) : l1.push_after_it(100);
    // for manual test find maximum elements
    // status - passed
    // l1.push_after_it(1000);
    // l1.push_after_it(1000);   
    cout << "Original list. \n\"list1\" : " << endl;
    for(l1.begin(); !l1.end(); l1.next())
        cout << l1.get() << ' ';
    cout << endl << endl;
    
    List<int> l2;
    if (l1.begin()){
       int max = l1.get() , i=1;
       l2.push_after_it(i);
       ++i;
       for (/*продолжаем*/ l1.next(); !l1.end(); l1.next()){
          if (l1.get() == max)
              l2.push_after_it(i);
          else if (l1.get() > max){
              l2.clear();
              max = l1.get();
              l2.push_after_it(i);
          }
          ++i;
       }
    }
    
    cout << "List with ordinal numbers of max. elements in \"list1\". \n\"list2\": " << endl;
    for(l2.begin(); !l2.end(); l2.next())
        cout << l2.get() << ' ';
    cout << endl << endl;        
}