Класс: однонаправленный список

/*
Создать класс LinkedList, в котором определены следующие операции: 
"+" -> дописывает элемент в конец списка; 
"+=" -> дописывает элемент в начало списка;
"-" - > удаляет указанный элемент из списка;
"=" - выполняет присвоение списков; 
"==, "!=", ">", "<", "=>", "<=" -> сравнение списков; 
"[]" -> получения элемента списка по его индексу; 
"++" -> установление указателя на следующий элемент; 
"()" -> вывод части списка между заданными элементами. 
*/
 
#include <iostream>
 
    using namespace std;
 
struct Node {
    int data;
    Node* next;
};
 
class LinkedList { //Объявляем класс LinkedList
 
    private:
        
        Node* node;
 
    public:
                
        Node* head = NULL;
        
        int size() { //Функция определения размера списка
            node = head;
            int k = 0;
            while (node != NULL) {
                k++;
                node = node->next;
            }
            return k;
        }
 
        void add_front(int data) { //Функция добавления элемента в начало списка
            node = new Node;
            node->data = data;
            node->next = head;
            head = node;
        }
 
        void add_back(int data) { //Функция добавления элемента в конец списка
            node = new Node;
            node->data = data;
            node->next = NULL;
            if (head == NULL) {
                head = node;
            } else {
                Node* curr = head;
                while (curr->next != NULL) {
                    curr = curr->next;
                }
                curr->next = node;
            }
        }
 
        void del(Node** node, int key) { //Функция удаления элемента из списка
            bool flag = false;
            Node* curr, *prev;
            prev = NULL;
            for (curr = *node; curr != NULL; prev = curr, curr = curr->next) {
                if (curr->data == key) {
                    flag = true;
                    if (prev == NULL) {
                        *node = curr->next;
                    } else {
                        prev->next = curr->next;
                    }
                    delete curr;
                    return;
                } 
            }
            if (!flag) {
                cout << "No any elements found to be deleted!\n";
            }
        }
        
        void find(int index) { //Функция получения элемента по его индексу 
            if (index >= 0 && index < size()) {
                Node* node = head;
                int ans, k = 0;
                while (node != NULL) {
                    if (k == index) {
                        cout << node->data << "\n";
                        break;
                    }
                    node = node->next;
                    k++;
                }
            } else {
                cout << "Element with such an index doesn't exist!\n";
            }
        }
        
        void extract(int l, int r) { //Функция получения части списка между двумя заданными индексами (включительно)
            if (l < r && l >= 0 && r < size()) {
                Node* node = head;
                int k = 0;
                    while (node != NULL) {
                        if (k >= l && k <= r) {
                        cout << node->data << " ";
                        }
                        k++;
                        node = node->next;
                    }
                } else {
                    cout << "No such interval exists!";
                } 
        }
        
        LinkedList &operator+(const int &data) { //Перегрузка оператора добавления элемента в конец списка 
            add_back(data);
            return *this;
        }
    
        LinkedList &operator+=(const int &data) { //Перегрузка оператора добавления элемента в начало списка 
            add_front(data);
            return *this;
        }
        
        LinkedList &operator-(const int &data) { //Перегрузка оператора удаления заданного элемента из списка 
            del(&head, data);
            return *this;
        }
        
        LinkedList &operator[](const int &index) { //Перегрузка оператора получения элемента списка по его индексу 
            find(index);
            return *this;
        }
        
        LinkedList &operator()(int l, int r) { //Перегрузка оператора вызов функции для вывода части списка
            extract(l, r);
            return *this;
        }
        
        LinkedList &operator=(LinkedList obj) { //Перегрузка оператора присваивания
            swap(head, obj.head);                    
            return *this;
        } 
        
        LinkedList &operator++() { //Перегрузка оператора пре-инкремента
            head = head->next;
            return *this;
        }
        
        LinkedList &operator++(int) { //Перегрузка оператора пост-инкремента
            head = head->next;
            return *this;
        }
            
        void print() { //Функция вывода списка на экран
            node = head;
            while (node != NULL) {
                cout << node->data << " ";
                node = node->next;
            }
        }
        
        LinkedList() { //Конструктор по умолчанию
            Node* head = NULL;
        }
    };  
    
bool operator==(LinkedList &lhs, LinkedList &rhs) { //Перегрузка операции проверки двух списков на равенство
    Node* a = lhs.head;
    Node* b = rhs.head;
    while (a != NULL && b != NULL) { 
        if (a->data != b->data) {
            return false; 
        }
        a = a->next; 
        b = b->next; 
    }
    if (lhs.size() != rhs.size()) {
        return false;
    }
    return true;
}
 
bool operator!=(LinkedList &lhs, LinkedList &rhs) { //Перегрузка операции проверки двух списков на неравенство
    Node* a = lhs.head;
    Node* b = rhs.head;
    while (a != NULL && b != NULL) { 
        if (a->data != b->data) {
            return true; 
        }
        a = a->next; 
        b = b->next; 
    }
    if (lhs.size() != rhs.size()) {
        return true;
    }
    return false;
}
 
bool operator>(LinkedList &lhs, LinkedList &rhs) { //Перегрузка операции ">" для списков равной длины
    Node* a = lhs.head;
    Node* b = rhs.head;
    while (a != NULL && b != NULL) { 
        if (a->data > b->data) {
            return true; 
        }
        a = a->next; 
        b = b->next; 
    }
    return false;
}
 
bool operator<(LinkedList &lhs, LinkedList &rhs) { //Перегрузка операции "<" для списков равной длины
    Node* a = lhs.head;
    Node* b = rhs.head;
    while (a != NULL && b != NULL) { 
        if (a->data < b->data) {
            return true; 
        }
        a = a->next; 
        b = b->next; 
    }
    return false;
}
 
bool operator>=(LinkedList &lhs, LinkedList &rhs) { //Перегрузка операции ">=" для списков равной длины
    Node* a = lhs.head;
    Node* b = rhs.head;
    while (a != NULL && b != NULL) { 
        if (a->data >= b->data) {
            return true; 
        }
        a = a->next; 
        b = b->next; 
    }
    return false;
}
 
bool operator<=(LinkedList &lhs, LinkedList &rhs) { //Перегрузка операции "<=" для списков равной длины
    Node* a = lhs.head;
    Node* b = rhs.head;
    while (a != NULL && b != NULL) { 
        if (a->data <= b->data) {
            return true; 
        }
        a = a->next; 
        b = b->next; 
    }
    return false;
}
 
int main() {
    //Примеры допустимых операций:
    //1. Добавление элемента в конец списка.
    LinkedList obj1; 
    obj1 + 1; 
    obj1 + 2;
    obj1 + 3;
    obj1.print();
    cout << "\n";
    //2. Добавление элемента в начало списка.
    LinkedList obj2;
    obj2 += 4;
    obj2 += 5;
    obj2 += 6;
    obj2.print();
    cout << "\n";
    //3. Сравнение двух списков.
    if (obj2 == obj1) {
        cout << "True!";
    } else {
        cout << "False!";
    }
    cout << "\n";
    //4. Присвоение одного списка другому.
    obj2 = obj1;
    obj2.print();
    cout << "\n";
    //5. Установление указателя на следующий элемент.
    obj1++;
    obj1.print();
    cout << "\n";
    //6. Вывод части списка между двумя заданными индексами.
    obj2(0, 1);
    cout << "\n";
    //7. Получение элемента списка по заданному индексу.
    obj2[0];
    //8. Удаление заданного элемента из списка.
    LinkedList obj3;
    obj3 + 6;
    obj3 + 7;
    obj3 + 8;
    obj3 - 7; //Удаляем 7 из 6 7 8
    obj3.print();
    cout << "\n";
    system("pause");
    return 0;
}

#include <iostream>
#include <conio.h> 
#include <cstring>
#include <string>
 
using namespace std;
int i;
//
string nameS;
string surnameS;
//
string nameD;
string surnameD;
class Person
{
public:
void show_info() {
cout << "\nПерсона:" << endl;
};
};
class Student : public Person
{
public:
void show_info() {
cout << "\nСтудент << " << surnameS << " " << nameS << endl;
};
};
class Dyplomnuk : public Person
{
void show_info() {
cout << "\nДипломник << " << surnameD << " " << nameD << endl;
}
};
int main()
{
setlocale(0, "RUS");
 
cout << "\nСтудент:" << endl;
cout << "Введите имя:";
cin >> nameS;
cout << "Введите фамилию:";
cin >> surnameS;
cout << "\nДипломник:" << endl;
cout << "Введите имя:";
cin >> nameD;
cout << "Введите фамилию:";
cin >> surnameD;
Person* start;
Student* st = new Student;
Dyplomnuk* dp = new Dyplomnuk;
start = st;
start = dp;
Person* fox[2];
fox[0] = st;
fox[1] = dp;
for (i; i < 3; i++) {
fox[i]->show_info();
}
system("pause");
return 0;
}