Реализовать указанные функции-члены для пользовательского класса "Кольцевой двусвязный список" - C++ - Ответ 9650524

//LinkedList.hpp
 
#pragma once
 
template <typename T>
class LinkedList
{
private:
    struct ListItem
    {
        ListItem() : Prev(this), Next(this) {}
 
        ListItem(const T &value, ListItem *prev, ListItem *next) : Value(value), Prev(prev), Next(next) {}
 
        ~ListItem() 
        {
            Prev->Next = Next;
            Next->Prev = Prev;
        } 
 
        T Value;
        ListItem *Prev;
        ListItem *Next;
    };
public:
    class iterator
    {
    public:
        bool operator==(const iterator &other) const
        {
            return _position == other._position;
        }
 
        bool operator!=(const iterator &other) const
        {
            return _position != other._position;
        }
 
        T &operator*() const
        {
            return _position->Value;
        }
 
        T *operator->() const
        {
            return &(_position->Value);
        }
 
        iterator &operator++()
        {
            _position = _position->Next;
            
            return *this;
        }
 
        iterator operator++(int)
        {
            iterator temp = *this;
 
            _position = _position->Next;
 
            return temp;
        }
 
        iterator operator--()
        {
            _position = _position->Prev;
            
            return *this;
        }
 
        iterator operator--(int)
        {
            iterator temp = *this;
 
            _position = _position->Prev;
 
            return temp;
        }
 
        iterator &operator=(const iterator &other)
        {
            if (this != &other)
                _position = other._position;
 
            return *this;
        }
 
        friend class LinkedList;
    private:
        iterator(ListItem *position) : _position(position) {}
 
        ListItem *_position;
    };
public:
    LinkedList()
    {
        _head = new ListItem();
    }
 
    ~LinkedList() 
    {
        if (!empty())
        {
            iterator last = end(), it = begin();
 
            while (it != last)
                remove(it++);
 
            remove(it);
        }
    };
 
    LinkedList(const LinkedList &other)
    {
        _head = new ListItem();
 
        InitializeFrom(other);
    }
 
    LinkedList &operator=(const LinkedList &other)
    {
        if (this != &other)
            InitializeFrom(other);
 
        return *this;
    }
 
    iterator begin() const
    {
        return iterator(_head->Next);
    }
 
    iterator end() const
    {
        return iterator(_head);
    }
 
    void remove(iterator what)
    {
        delete what._position;
    }
 
    bool empty() const
    {
        return end() == begin();
    }
 
    void insert(iterator where, T value)
    {
        ListItem *wherePtr = where._position, *prevPtr = (--where)._position;
        ListItem *insertItemPtr = new ListItem(value, prevPtr, wherePtr);
 
        prevPtr->Next = insertItemPtr;
        wherePtr->Prev = insertItemPtr;
    }
 
    void push_back(T value)
    {
        insert(end(), value);
    }
 
    void push_front(T value)
    {
        insert(begin(), value);
    }
 
private:
    void InitializeFrom(const LinkedList &other)
    {
        if (other.empty())
            return;
 
        iterator it = begin(), another = other.begin();
 
        while (another != other.end())
        {
            if (it == end())
                push_back(*another);
            else
            {
                *it = *another;
                ++it;
            }
 
            ++another;
        }
    }
 
    ListItem *_head;
};