SLList.h

#pragma once
#include <iostream>
#include <regex>
#include <sstream>
#include <filesystem>
#include <fstream>

    using namespace std;

    template<typename T>
    class SinglyLinkedList
    {
    public:
        SinglyLinkedList();
        SinglyLinkedList(const SinglyLinkedList& other);
        ~SinglyLinkedList();
        void push_back(T data);
        void push_front(T data);
        void pop_front();
        void clear();
        void build_empty(size_t sizeOfList);
        void insert(T data, int index);
        void removeAt(int index);
        void pop_back();
        int getSize() { return size; }
        T operator[] (const int index);
    private:
        template<typename T>
        class Node
        {
        public:
            Node* pNext;
            T data;
            Node(T data = T(), Node* pNext = nullptr)
            {
                this->data = data;
                this->pNext = pNext;
            }
        };
        Node<T>* head;
        size_t size;
    };

    template<typename T>
    SinglyLinkedList<T>::SinglyLinkedList()
    {
        size = 0;
        head = nullptr;
    }

    template<typename T>
    SinglyLinkedList<T>::SinglyLinkedList(const SinglyLinkedList& other) : SinglyLinkedList()
    {
        Node<T>* current = other.head;
        while (current != nullptr)
        {
            push_back(current->data);
            current = current->pNext;
        }
    }

    template<typename T>
    SinglyLinkedList<T>::~SinglyLinkedList()
    {
        clear();
    }

    template<typename T>
    void SinglyLinkedList<T>::push_back(T data)
    {
        if (head == nullptr)
        {
            head = new Node<T>(data);
        }
        else
        {
            Node<T>* current = this->head;
            while (current->pNext != nullptr)
            {
                current = current->pNext;
            }
            current->pNext = new Node<T>(data);
        }
        size++;
    }

    template<typename T>
    void SinglyLinkedList<T>::pop_front()
    {
        Node<T>* temp = head;
        head = head->pNext;
        delete temp;
        size--;
    }

    template<typename T>
    T SinglyLinkedList<T>::operator[](const int index)
    {
        size_t counter = 0;
        Node<T>* current = this->head;
        while (current != nullptr)
        {
            if (counter == index)
            {
                return current->data;
            }
            ++counter;
            current = current->pNext;
        }
    }

    template<typename T>
    void SinglyLinkedList<T>::clear()
    {
        while (size)
        {
            pop_front();
        }
    }

    template<typename T>
    void SinglyLinkedList<T>::build_empty(size_t sizeOfList)
    {
        for (size_t i = 0; i < sizeOfList; ++i)
        {
            push_back(T());
        }
    }

    template<typename T>
    void SinglyLinkedList<T>::push_front(T data)
    {
        head = new Node<T>(data, head);
        size++;
    }

    template<typename T>
    void SinglyLinkedList<T>::insert(T data, int index)
    {
        if (index == 0)
        {
            push_front(data);
        }
        else
        {
            Node<T>* previous = this->head;
            for (size_t i = 0; i < index - 1; ++i)
            {
                previous = previous->pNext;
            }
            Node<T>* newNode = new Node<T>(data, previous->pNext);
            previous->pNext = newNode;
            ++size;
        }
    }

    template<typename T>
    void SinglyLinkedList<T>::removeAt(int index)
    {
        if (index == 0)
        {
            pop_front();
        }
        else
        {
            Node<T>* previous = this->head;
            for (size_t i = 0; i < index - 1; ++i)
            {
                previous = previous->pNext;
            }
            Node<T>* temp = previous->pNext;
            previous->pNext = temp->pNext;
            delete temp;
            size--;
        }
    }

    template<typename T>
    void SinglyLinkedList<T>::pop_back()
    {
        removeAt(size - 1);
    }

    template<typename T>
    void print(SinglyLinkedList<T> list)
    {
        cout << endl << "№\t" << "элемент" << endl;
        for (size_t i = 0; i < list.getSize(); ++i)
        {
            cout << i + 1 << "\t" << list[i] << endl;
        }
        cout << endl;
    }

    template<typename T>
    unsigned short allEntryOfElement(T element, SinglyLinkedList<T> list)
    {
        unsigned short counter = 0;
        for (size_t i = 0; i < list.getSize(); ++i)
        {
            if (element == list[i])
                counter++;
        }
        return counter;
    }

    bool isFileCorrect(string path);

    string readFilePath(bool flag);

    template<typename T>
    void getListFromFile(SinglyLinkedList<T>& list)
    {
        bool flag = true;
        string path = readFilePath(flag);
        string inputline;
        cmatch res;
        regex reg("(\\d+)\\s*");
        fstream fin(path, std::ios_base::in);
        while (!fin.eof())
        {
            getline(fin, inputline);
            auto inputline_begin = sregex_iterator(inputline.begin(), inputline.end(), reg);
            auto inputline_end = sregex_iterator();
            for (auto i = inputline_begin; i != inputline_end; ++i)
            {
                list.push_back(stoi((*i).str()));
            }
        }
        fin.close();
    }

    int readElement(int data);

    void getListElementFromConsole(SinglyLinkedList<int>& list);

    int getMainMenuItem(bool item5);

    int readSizeOfEmptyList();

    size_t readDeletableElementIndex(size_t index, SinglyLinkedList<int>& list);

    string readFilePath();

    void saveList(SinglyLinkedList<int>& list);

    void selectMenuItem(int menuItem, SinglyLinkedList<int>& list);

    void showMenu(SinglyLinkedList<int> list);

    void selectMainMenuItem(int menuItem);

    void showMainMenu();