Линейный двунаправленный список из вещественных чисел

#pragma once
#include <iostream>
// Двух связный список
template <typename T>class List
{
public: // Объявляем в public, чтобы обращатся в main()
    struct Node // Структура для значений в двух связном списке
    {
        T i; // Значение какое хранится в списке
        Node *pNext; // Ссылка на следующий элемент списка
        Node *pRev; // Ссылка на предыдущий элемент списка
    };
private:
    Node *pHead; // Ссылка на вершину, списка
    Node *pEnd; // Ссылка на конец, Списка
public:
    // Конструктор
    List() :pHead(nullptr), pEnd(nullptr) // обнуляем указатели класса
    {
    }
    List(const List&l) // Конструктор копирования
    {
        Node * pCpy = l.pHead; // Создаем временую переменую 
        while (pCpy) // Ходим по списку до 0
        {
            this->Add(pCpy->i); // Вставляем значение в конец списка
            pCpy = pCpy->pNext; // Получаем ссылку на новый элемент списка
        }
    }
    List& operator =(const List&l) // Перегрузка оператора =
    {
        if (this == &l) // Проверяем на самоприсваивание
            return *this; // Если ссылки равны, возвращаем указатель на существующий объект
        this->Clear(); // удаляем содержимое из списка
        Node * pCpy = l.pHead; // Переменная для копировния
        while (pCpy) // Ходим по списку пока не встретим 0
        {
            this->Add(pCpy->i); // Вставляем в конец данные
            pCpy = pCpy->pNext; // Получаем ссылку на новый элемент списка
        }
        return *this; // Возвращаем новый объект
    }
    List(List&&l) // Конструктор переноса
    {
        if (this != l) // Проверяем на самоприсваивание
        {
            this->pHead = l.pHead; // Перенаправл ссылку
            l.pHead = nullptr; // обнуляем && ссылку
        }
    }
    List& operator=(List &&l) // Перегрузка оператора переноса
    {
        if (this == д)// Проверка на самоприсваивание
            return *this; // Возвращаем существующий объект
        this->Clear(); // Обнуление существующей 
        this->pHead = l.pHead; // Перенаправляем ссылку
        l.pHead = nullptr; // Обнуляем ссылку
        return *this; //  Возвращаем существующий объект
    }
    // Деструктор
    ~List()
    {
        Node *p = this->pHead; // Ссылаемся на голову
        while (p) // Двигаемся по списку до 0
        {
            this->pHead = p->pNext; // Голове присваиваем значение следующего
            delete p; // Удаляем 
            p = this->pHead; // Переприсваиваем новое значение
        }
    }
    void Add(const T&i) // Метод добавление нового элемента в конец списка
    {
        Node *p = new Node{ i,nullptr,nullptr }; // Инициализируем новый элемент списка
        if (!this->pHead)  // Если список пустой
        {
            this->pHead = this->pEnd = p; // Ложем в начало новый элемент
            return; // Конец
        }
        this->pEnd->pNext = p; // Добавляем в конец
        p->pRev = this->pEnd; // Связываем предыдущий с концем 
        this->pEnd = p; // И ставим указатель на конец на новый элемент
    }
 
    Node * Insert(Node*pos, const T&i)// Вставка нового элемента в любую позицию
    {
        Node * p = new Node{ i,nullptr,nullptr }; // Создаем новый элемент списка
        if (pos == this->pHead) // Вставляем элемент вместо первого элемента
        { // Перенастраиваем указатели
            p->pNext = this->pHead; // Следующий у переменной p будет ссылатся на старую вершину
            this->pHead->pRev = p; // У старой вершины предыдущий будет ссылатса на новую вершину
            this->pHead = p; // Новая верщина
        }
        else if (pos == this->pEnd) // Вставляем вместо последнего элемента, а последний в конец 
        {
            p->pNext = this->pEnd; // Следующий у переменной p будет ссылатся на старый конец
            p->pRev = this->pEnd->pRev; // У старого конца предыдущий будет ссылатса на предыдущий старого конца
            (this->pEnd->pRev)->pNext = p; // А предыдущий старой вершины, его следующий теперь будет ссылка на p
            (this->pEnd)->pRev = p; // И предыдущий старой верщины будет ссылатся на p
        }
        else // Вставляем в середину 
        {
            pos->pRev->pNext = p; // перенаправляем следующий исходной точки на переменную p
            p->pRev = pos->pRev; // у переменной p предыдущий будет ссылаться на предыдущий исходной позиции
            pos->pRev = p; // и теперь предыдущий у исходой позиции будет ссылаться на p
            p->pNext = p; // и p->pNext будет ссылатся на p
        }
        return p; // Возвращаем новый элемент
    }
    bool IsEmpty(void)const // Метод проверки на пустоту списка
    {
        return !this->pHead; // Возвращаем true если голова 0, и false если список не пустой
    }
    void Print(void)// Выводит на консоль с лева на право
    {
        const Node* p = this->pHead; // Указатель на начало нашего списка
        while (p) // Ходим по списку до 0
        {
            std::cout << p->i << " "; // Выводим значения
            p = p->pNext; // Перехим к следующему
        }
        std::cout << std::endl; // В конце Enter
    }
    void Printreverse(void)const // Выводит на консоль с право на лево
    {
        const Node * p = this->pEnd; // Создаем буффер 
        while (p) // Идем по списку до конца
        {
            std::cout << p->i << std::ends; // выводи на консоль
            p = p->pRev; // меняем ссылку на передыдущюю
        }
        std::cout << std::endl; // Enter
    }
    
    Node* Find(const T&i)const // Метод поиска нужного указатель в котором хранится нужное нам число
    {
        Node *p = this->pHead; // Ссылаемся на голову
        while (p) // идем по списку до конца
        {
            if (p->i == i) // если находим нужное значение
                return p;// Возвращаем нужный нам элемент списка
            p = p->pNext;// перенаправляем ссылку на следующий
        }
        return nullptr;// возвращаем nullptr
    }
    
    Node* FirstPage()const // Метод возвращающий указатель на начало списка 
    {
        return this->pHead;// возвращаем указатель на начало списка
    }
    Node * EndPage()// Метод возвращающий указатель на конец списка
    {
        return this->pEnd; // возвращаем указатель на конец списка
    }
    Node * operator[](const size_t &i)  // Добавить оператор индексации
    {
        int count = 0; // счетчик
        Node * p = this->pHead; // Ссылаемся на голову
        while (p) // Идем по списку до конца пока не встретим нужный 
        {
            if (count == i) // Если счетчик равен i
                return p; // Возвращаем нужный нам элемент списка
            count++; // увеличиваем счетчик +1
            p = p->pNext;// перенаправляем ссылку на следующий
        }
        std::cout << "Exception this index, does not exist" << std::endl; // Если не нашли нужную, возвращаем ошибку
        return nullptr; // возвращаем nullptr
    }
 
    void DeleteElement(const T&i)// Метод удаляющий по значению
    {
        Node *p = this->pHead;  // начинаем с головы
        while (p)     // пока не конец списка
        {
            if (p->i == i)   // совпадение ключа 
            {
                Node *pRemove = p;  // то что будем удалять
                if (pRemove == this->pHead) // если удаляем голову
                {
                    this->pHead = this->pHead->pNext;  // теперь голова это второй эл-т списка
                }
                else if (pRemove == this->pEnd)    // если искомый равен последнему элементу
                {
                    this->pEnd = this->pEnd->pRev;   // теперь хвост - предыдущий эл-т,
                    this->pEnd->pNext = nullptr;   // а следующий его - nullptr
                }
                else          // если удаляем с середины списка          
                {
                    pRemove->pRev->pNext = pRemove->pNext; // предыдущий удаляемого указывает на следующий от удаляемого
                    pRemove->pNext->pRev = pRemove->pRev; // а предыдущий следующего должен указывать на предыдущий от удаляемого
                }
                p = pRemove->pNext;   // перемещаемся дальше по очереди
                delete pRemove;     // удаление найденого элемента
            }
            else
                p = p->pNext;   // перемещаемся дальше по очереди и ищем дальше ключи
        }
    }
        
    void DeleteElement(const Node*i)// Метод удаляющий по ссылке на структуру Node
    {
        Node * p = this->pHead; // Ссылаемся на голову 
        while (p) // Двигаемся по списку до нужного элемента
        {
            if (p == i) // Проверяем равны ссылки или нет
            {
                Node *pRemove = p;  // то что будем удалять
                if (pRemove == this->pHead) // если удаляем голову
                {
                    this->pHead = this->pHead->pNext;  // теперь голова это второй эл-т списка
                }
                else if (pRemove == this->pEnd)    // если искомый равен последнему элементу
                {
                    this->pEnd = this->pEnd->pRev;   // теперь хвост - предыдущий эл-т,
                    this->pEnd->pNext = nullptr;   // а следующий его - nullptr
                }
                else          // если удаляем с середины списка          
                {
                    pRemove->pRev->pNext = pRemove->pNext; // предыдущий удаляемого указывает на следующий от удаляемого
                    pRemove->pNext->pRev = pRemove->pRev; // а предыдущий следующего должен указывать на предыдущий от удаляемого
                }
                p = pRemove->pNext;   // перемещаемся дальше по очереди
                delete pRemove;     // удаление найденого элемента
                return;
            }
            p = p->pNext; // передвигаемся на следующий элемент списка
        }
    }
    void Clear() // Метод удаление содержимого листа
    {
        Node *p = this->pHead; // Ссылаемся на голову
        while (p) // Двигаемся по списку до 0
        {
            this->pHead = p->pNext; // Голове присваиваем значение следующего
            delete p; // Удаляем 
            p = this->pHead; // Переприсваиваем новое значение
        }
    }
 
    bool isPalindrome(Node * pNode)
    {
        Node * p = pNode;
        while (p != nullptr)
        {
            p = p->pNext;
            isPalindrome(p);
        }
        if (p->i == pNode->i)
        {
            pNode = pNode->pNext;
            return true;
        }
        return false;
    }
};