#include <iostream>

template <typename value_type>
class LinkedList
{
    friend class iterator;
private:
    m_element * m_head;
    struct m_element
    {
        value_type m_data;
        m_element * next;
        m_element * prev;
    };

public:
    class iterator
    {
        private:
        LinkedList * m_current_list;
        m_element * m_current_item;
        public:
            iterator()
            {
                m_current_list = NULL;
                m_current_item = NULL;
            };
            iterator(const iterator & other)
            {
                m_current_item = other.m_current_item;
                m_current_list = other.m_current_list;
            };

            iterator & operator=(const iterator & other)
            {
                m_current_item = other.m_current_item;
                m_current_list = other.m_current_list;
                return *this;
            };
            bool operator!=(const iterator & other) const
            {
                return (m_current_item != other.m_current_item);
            };
            bool operator==(const iterator & other) const
            {
                return (m_current_item == other.m_current_item);
            };
            //Возвращает ссылку на текущий элемент коллекции.
            value_type & operator*() const
            {
                return (*m_current_item);
            };
            //Возвращает указатель на текущий элемент коллекции.
            value_type * operator->() const
            {
                return m_current_item;
            };

            iterator & operator++()
            {
                if (m_current_item)
                {
                    m_current_item = m_current_item->next;
                }
                else
                {
                    m_current_item = m_current_list->m_head;
                }
                return (*this);
            };

            iterator operator++(int)
            {
                iterator for_return(*this);
                if (m_current_item)
                {
                    m_current_item = m_current_item->next;
                }
                else
                {
                    m_current_item = m_current_list->m_head;
                }
                return (for_return);
            };

            iterator & operator--()
            {
                if (m_current_item)
                {
                    m_current_item = m_current_item->prev;
                }
                else
                {
                    m_current_item = m_current_list->m_head->prev;
                }
                return (*this);
            };

            iterator operator--(int)
            {
                iterator for_return(*this);
                if (m_current_item)
                {
                    m_current_item = m_current_item->prev;
                }
                else
                {
                    m_current_item = m_current_list->m_head->prev;
                }
                return (for_return);
            };
    };
    LinkedList();
    LinkedList(const LinkedList & other);
    ~LinkedList();

    //Возвращает ссылку на первый элемент списка.
    value_type & front()
    {
    };
    const value_type & front() const;
    //Возвращает ссылку на последний элемент списка.
    value_type & back();
    const value_type & back() const;

    //Возвращает итератор, указывающий на первый элемент списка.
    iterator begin();
    //Возвращает итератор, указывающий на элемент списка, следующий за последним
    //т.е. отсутствующий в списке.
    iterator end();

    //Возвращает истину, если значение value содержится в списке.
    bool contains(const value_type & value) const;
    //Возвращает количество вхождений значения value в список.
    int count(const value_type & value) const;
    //Возвращает размер списка.
    int size() const;
    //Возвращает истину, если список пуст.
    bool empty() const;

    //Удаляет элемент, на который указывает итератор pos.
    iterator erase(iterator pos);
    //Удаляет элементы в интервале [begin, end).
    iterator erase(iterator begin, iterator end);

    //Очищает список.
    void clear();
    //Удаляет все вхождения value в список.
    int removeAll(const value_type & value);
    //Удаляет первое вхождение value в список.
    bool removeOne(const value_type & value);

    //Удаляет последний элемент списка.
    void pop_back();
    //Удаляет первый элемент списка.
    void pop_front();
    //Добавляет значение value в конец списка.
    void push_back(const value_type & value);
    //Добавляет значение value в начало списка.
    void push_front(const value_type & value);
    //Вставляет значение value перед элементом, на который указывает before
    iterator insert(iterator before, const value_type & value);

    bool operator!=(const LinkedList & other) const;
    bool operator==(const LinkedList & other) const;

    //Присоединяет other к списку.
    LinkedList operator+(const LinkedList & other) const;
    LinkedList & operator+=(const LinkedList & other);
    //Присоединяет value к списку.
    LinkedList & operator+=(const value_type & value);

    LinkedList & operator=(const LinkedList & other);
};

int main()
{
    return 0;
}