Перегрузка операторов в односвязном списке С++

#include <iostream>
 
using namespace std;
 
template<typename T>
class List
{
public:
    List();
    ~List();
    void push_back(T data);
    void pop_front();
    void operator+=(T data);
    void operator+(T data);
    void operator-(int index);
    void operator++(int index);
    T& operator=(T &b);
    T& operator[](const int index);
    int GetSize() { return Size; };
 
private:
    template<typename T>
    class Note {
 
    public:
        Note *pNext;
        T data;
        Note(T data = T() ,Note *pNext = nullptr)
        {
            this->data = data;
            this->pNext = pNext;
        }
    };
 
int Size;
Note<T> *head;
};
 
 
int main() {
    setlocale(LC_ALL, "ru");
    List<int> first;
    List<int> second;
    first.push_back(1);
    first.push_back(2);
    first +=(3);
    first +(4);
    first +(5);
    first ++;
    second = first;
    cout << second[1] << endl;
    cout << "Удаляем елемент" << endl;
    for (int i = 0; i < first.GetSize(); i++) 
    {
        cout << first[i] << endl;
    }
    cout << "Удаляем елемент" << endl;
    first -(1);
    for (int i = 0; i < first.GetSize(); i++)
    {
        cout << first[i] << endl;
    }
    system("pause");
    return 0;
}
 
template<typename T>
List<T>::List()
{
    Size = 0;
    head = nullptr;
}
template<typename T>
List<T>::~List()
{
}
template<typename T>
void List<T>::push_back(T data)
{
    if (head == nullptr) 
    {
        head = new Note<T>(data);
    }
    else
    {
        Note<T> *current = this->head;
        while (current->pNext != nullptr) {
            current = current->pNext;
        }
        current->pNext = new Note<T>(data);
    }
    Size++;
}
 
template<typename T>
void List<T>::operator+=(T data)
{
    head = new Note<T>(data,head);
    Size++;
}
 
template<typename T>
void List<T>::operator+(T data)
{
    Note<T> *current = this->head;
    if (head == nullptr) {
        head = new Note<T>(data);
    }
    else
    {
        while (current->pNext != nullptr)
        {
            current = current->pNext;
        }
        current->pNext = new Note<T>(data);
    }
    Size++;
}
 
template<typename T>
void List<T>::operator-(int index)
{
    if (index == 0) {
        pop_front();
    }
    else
    {
        Note <T> *previous = this->head;
        for (int i = 0; i < index - 1; i++)
        {
            previous = previous->pNext;
        }
        Note<T> *toDelete = previous->pNext;
        previous->pNext = toDelete->pNext;
        delete toDelete;
        Size--;
    }
}
 
template<typename T>
void List<T>::operator++(int index)
{
    int counter = 0;
    Note<T> *current = this->head;
    while (current != nullptr)
    {
        if (counter == index) {
            current->data;
            current = current->pNext;
            current->pNext;
        }
        current = current->pNext;
        counter++;
    }
}
 
template <typename T>
T& List<T>::operator=(T &b) {
    if (this != &b) {
        (*this).List<T>::~List();
        (*this).List<T>::List(b);
    }
    return *this;
}
 
template<typename T>
T &List<T>::operator[](const int index)
{
    int counter = 0;
    Note<T> *current = this->head;
    while (current != nullptr)
    {
        if (counter==index) 
        {
            return current->data;
        }
        current = current->pNext;
        counter++;
    }
}
 
template<typename T>
void List<T>::pop_front()
{
    Note<T> *temp = head;
    head = head->pNext;
    delete temp;
    Size--;
}