list的模拟实现，有复用的反向迭代器

#pragma once
namespace bit
{
    // List的节点类
    template<class T>
    struct ListNode
    {

        ListNode(const T& val = T())//构造函数
        {
            _val = val;
            _pNext = nullptr;
            _pPre = nullptr;
        }
        ListNode<T>* _pPre = nullptr;//节点类的成员变量
        ListNode<T>* _pNext = nullptr;
        T _val;
    };

    //List的迭代器类
    template<class T, class Ref, class Ptr>
    class ListIterator
    {
        typedef ListNode<T>* PNode;
        typedef ListIterator<T, Ref, Ptr> Self;//迭代器类型 和 节点指针类型
    public:
        ListIterator(PNode pNode = nullptr)//构造函数
        {
            _pNode = pNode;
        }
        ListIterator(const Self& l)//拷贝构造
        {
            _pNode = l._pNode;
        }
        Ref operator*()//这些解引用，我们希望的是返回节点的值
        {
            return _pNode->_val;
        }
        Ptr operator->()//同上
        {
            return &_pNode->_val;
        }
        Self& operator++()//迭代器++
        {
            _pNode = _pNode->_pNext;
            return *this;
        }
        Self operator++(int)
        {
            Self tmp = *this;//拷贝构造一份，因为是后置++
            _pNode = _pNode->_pNext;
            return tmp;
        }
        Self& operator--()
        {
            _pNode = _pNode->_pPre;
            return *this;
        }
        Self& operator--(int)
        {
            Self tmp = *this;//拷贝构造一份，因为是后置++
            _pNode = _pNode->_pPre;
            return tmp;
        }
        bool operator!=(const Self& l)
        {
            return _pNode != l._pNode;
        }
        bool operator==(const Self& l)
        {
            _pNode == l._pNode;
        }
        PNode _pNode;//这个写公有好一点吧，因为list类也需要用迭代器，需要访问这些
    };
    template<class Iterator,class Ref,class Ptr>
    struct reverse_ListIterator
    {
        typedef reverse_ListIterator<Iterator, Ref, Ptr> rSelf;
        Iterator _it;

        reverse_ListIterator(Iterator it=nullptr)
            :_it(it)
        {}

        Ref operator*()
        {
            Iterator tmp = _it;
            tmp--;
            return *tmp;
        }
        rSelf& operator++()
        {
            --_it;
            return *this;
        }
        rSelf operator++(int)
        {
            Iterator tmp = _it;
            --_it;
            return tmp;
        }
        rSelf& operator--()
        {
            ++_it;
            return *this;
        }
        rSelf operator--(int)
        {
            Iterator tmp = _it;
            ++_it;
            return tmp;
        }
        bool operator!=(const rSelf& l)
        {
            return _it != l._it;
        }
        bool operator==(const rSelf& l)
        {
            return _it == l._it;
        }
    };
    /*template <class Iterator, class Ref, class Ptr>
    struct reverse_ListIterator
    {
        typedef reverse_ListIterator<Iterator, Ref, Ptr> self;
        Iterator _cur;

        reverse_ListIterator(Iterator it)
            :_cur(it)
        {}

        Ref operator*()
        {
            Iterator tmp = _cur;
            --tmp;
            return *tmp;
        }

        self& operator++()
        {
            --_cur;
            return *this;
        }
        self operator++(int)
        {
            self tmp(*this);
            --_cur;
            return tmp;
        }

        self& operator--()
        {
            ++_cur;
            return *this;
        }
        self operator--(int)
        {
            self tmp(*this);
            ++_cur;
            return tmp;
        }

        bool operator!=(const self& s)
        {
            return _cur != s._cur;
        }
    };*/
    //list类
    template<class T>
    class list
    {
        typedef ListNode<T> Node;
        typedef Node* PNode;
    public:
        typedef ListIterator<T, T&, T*> iterator;//迭代器
        typedef ListIterator<T, const T&, const T*> const_iterator;
        typedef reverse_ListIterator<iterator, T&, T*> reserve_iterator;//迭代器
        typedef reverse_ListIterator<const_iterator, const T&, const T*> const_reserve_iterator;
    public:
        ///
        // List的构造
        void empty_init()//初始化list
        {
            _pHead = new Node;//开一个头节点
            _pHead->_pPre = _pHead;
            _pHead->_pNext = _pHead;
            _size = 0;
        }
        list()
        {
            _pHead = new Node;//开一个头节点
            _pHead->_pPre = _pHead;
            _pHead->_pNext = _pHead;
            _size = 0;
        }
        list(int n, const T& value = T())//n个元素构造，T是元素类型
        {
            empty_init();
            for (int i = 0; i < n; i++)
            {
                push_back(value);
            }
        }
        template <class Iterator>
        list(Iterator first, Iterator last)//迭代器区间构造
        {
            empty_init();
            while (first != last)
            {
                push_back(*first);//first迭代器的成员变量是节点指针，重载的解引用得到的是元素
                ++first;
            }
        }
        list(const list<T>& l)//拷贝构造
        {
            empty_init();
            for (auto e : l)
            {
                push_back(e);//一个一个插入
            }
        }
        list<T>& operator=(const list<T> l)//赋值运算符重载
        {
            clear();//清空原来的
            for (auto e : l)
            {
                push_back(e);//一个一个插入
            }
            return *this;
        }
        ~list()
        {
            clear();//其他节点的释放
            delete this->_pHead;//头节点的释放
        }

        ///
        // List Iterator
        iterator begin()
        {
            return _pHead->_pNext;
        }
        iterator end()
        {
            return _pHead;
        }
        const_iterator begin() const
        {
            return _pHead->_pNext;
        }
        const_iterator end()const
        {
            return _pHead;
        }
        reserve_iterator rbegin()
        {
            return end();
        }
        reserve_iterator rend()
        {
            return begin();
        }
        const_reserve_iterator rbegin()const
        {
            return end();
        }
        const_reserve_iterator rend()const
        {
            return begin();
        }
        ///
        // List Capacity
        size_t size()const
        {
            return _size;
        }
        bool empty()const
        {
            if (_size == 0)
                return true;
            else
                return false;
        }


        
        // List Access
        T& front()
        {
            return _pHead->_pNext;
        }
        const T& front()const
        {
            return _pHead->_pNext;
        }
        T& back()
        {
            return _pHead;
        }
        const T& back()const
        {
            return _pHead;
        }


        
        // List Modify
        void push_back(const T& val) { insert(end(), val); }
        void pop_back() { erase(--end()); }
        void push_front(const T& val) { insert(begin(), val); }
        void pop_front() { erase(begin()); }
        // 在pos位置前插入值为val的节点
        iterator insert(iterator pos, const T& val)
        {
            PNode tmp = new Node(val);//堆上开节点
            PNode cur = pos._pNode;
            cur->_pPre->_pNext = tmp;//pos前一个指向插入节点
            tmp->_pPre = cur->_pPre;//插入节点指向pos前一个
            tmp->_pNext = cur;
            cur->_pPre = tmp;
            ++_size;
            return iterator(tmp);
        }
        // 删除pos位置的节点，返回该节点的下一个位置
        iterator erase(iterator pos)
        {
            PNode tmp = pos._pNode;
            PNode ret = tmp->_pNext;
            tmp->_pPre->_pNext = tmp->_pNext;
            tmp->_pNext->_pPre = tmp->_pPre;
            delete tmp;//关键释放
            --_size;
            return iterator(ret);
        }
        void clear()
        {
            iterator it = begin();
            while (it != end())
            {
                it = erase(it);
            }
        }
        void swap(list<T>& l)
        {
            std::swap(this->_pHead, l._pHead);
            std::swap(this->_size, l._size);
        }
    private:
        void CreateHead()
        {

        }
        PNode _pHead;
        size_t _size = 0;
    };
}