Реализация функций erase,insert,clear - для односвязного списка

class List
{
private:
    size_t size;
    //------------------------------
        template<class T>
        class Node
        {
        public:
            Node* ptrNext;
            T data;
            Node(T data_ = T(), Node* ptrNext_ = nullptr)
            {
                this->data = data_;
                this->ptrNext = ptrNext_;
            }
        };
    //------------------------------
public:
    List();
    ~List();    
    Node<T>* head;
    void push_back(T data_);
    void erase(const size_t index);
    void insert(const size_t position, T date_);
    void clear();
    void lout();
    int getSize() { return size; };
    void randIntInit(size_t count,int min,int max);
    T& operator[](const size_t index);
    
};

template<class T>
void List<T>::erase(const size_t index)
{
        size_t counter{ 0 };
        Node<T>* current = this->head;
        Node<T>* ptrprevious = this->head;
        while (current != nullptr)
        {
            if (counter == index-1)
            {
                if (index-1 == 0)
                {
                    this->head = current->ptrNext;
                    delete current;
                    size--;
                    break;
                }
                else
                {
                    ptrprevious->ptrNext = current->ptrNext;
                    delete current;
                    size--;
                    break;
                }
            }
            else
            {
                ptrprevious = current;
                current = current->ptrNext;
                counter++;
            }
 
        }
}
//------------------------------

template<class T>
void List<T>::lout()
{   
    if (this->getSize()>0)
    {
        cout << "List elements count: " << this->getSize() << endl;
        Node<T>* current = this->head;
        size_t fakesize{ 1 };
        while (current != nullptr)
        {
            cout << fakesize << "::" << current->data << endl;
            current = current->ptrNext;
            fakesize++;
        }
        cout << endl;
    }
    else
    {
        cout << "List empty!" << endl;
    }
}
//------------------------------

template<class T>
void List<T>::clear()
{
    Node<T>* current = this->head;
    Node<T>* ptrprevious = this->head;
    while (current != nullptr)
    {   
        ptrprevious = current;
        current = current->ptrNext;
        delete ptrprevious;
        size--;
    }
}
//------------------------------

template<class T>
void List<T>::insert(const size_t position, T date_)
{
    Node<T>* current = this->head;
    Node<T>* ptrprevious = this->head;
    size_t counter{ 0 };
    while (current != nullptr)
    {
        if (counter == position-1)
        {
            if (position == 1)
            {
                this->head = new Node<T>(date_);
                this->head->ptrNext = ptrprevious;
                size++;
                break;
            }
            else
            {
                Node<T>* NewNode = new Node<T>(date_, current);
                ptrprevious->ptrNext = NewNode;
                size++;
                break;
            }
        }
        else
        {
            ptrprevious = current;
            current = current->ptrNext;
            counter++;
        }
    }
}

template<class T>
    bool List<T>::predicat_is_previous_element(const Node &obj)
    {
        if (find_previous(obj))
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    //------------------------------
 
    template<class T>
    bool List<T>::predicat_if_data(const T &data_)
    {
        Node* current = this->head;
        while (current->ptrNext != nullptr)
        {
            if (current->ptrNext->data == data_)
            {
                return true;
            }
            else
            {
                current = current->ptrNext;
            }
        }
        return false;
    }

template <typename T> template <typename TFunc>
typename List<T>::Node* List<T>::find_prev_if(TFunc &&pred)

template<class T>
    bool List<T>::predicat_if_data(const T &data_)
    {
        Node* current = this->head;
        while (current->ptrNext != nullptr)
        {
            if (current->ptrNext->data == data_)
            {
                return true;
            }
            else
            {
                current = current->ptrNext;
            }
        }
        return false;
    }

[&data](const T &val)
    {
        return data == val;
    }

[&index](const T &val)
    {
        return (index--) == 0;
    }

find_prev_if(TFunc &&pred)

[&data]

const T &val

template <typename T> template <typename TFunc>
typename List<T>::Node* List<T>::find_prev_if(TFunc &&pred)
{
    if (head->data==data_)
        return nullptr;
 
    Node* current = this->head;
    while (current->ptrNext && !pred(current->ptrNext->data))
    {       
        current = current->ptrNext;
    }
    return current;
}
 
template <typename T>
typename List<T>::Node* List<T>::find_prev(const T &data)
{
    return find_prev_if([&data](const T &val)
    {
        return data == val;
    });
}
 
template<class T>
void List<T>::erase(size_t index)
{
    auto *node = find_prev_if([&index](const T &val)
    {
        return (index--) == 0;
    });
 
    remove_next(node);
}