c++_list模仿库实现

1 list的概念

stl中的链表

2 链表的概念

开辟一块空间（一个节点），该空间包括需要储存的数据和下一个节点的地址

最简单的单链表：

为了更方便给链表加上一个头表示开始，以及上一个节点的地址变成带头双向链表:

带头双向链表:

3 模拟库实现list需要实现的类，迭代器，成员函数极其作用

3.1list的迭代器类

3.2链表节点类

3.3预备模拟实现的list成员函数

4 各种需要的类，迭代器与list成员函数代码

4.1节点类（代码）

// List的节点类
    template<class T>
    struct ListNode
    {
        //构造函数
        ListNode(const T& val = T())
            :_pPre(nullptr)
            , _pNext(nullptr)
            , _val(val)
        {}
        ListNode<T>* _pPre;
        ListNode<T>* _pNext;
        T _val;
    };

4.2list的迭代器（代码）

  //List的迭代器类
    //为了保证const_itreator和itreator的区别定义的模板类
    template<class T, class Ref, class Ptr>
    struct ListIterator
    {
        typedef ListNode<T>* PNode;
        //typedef ListIterator<T, T&, T*> iterator;
        //typedef ListIterator<T, const T&, const T*> const_iterator;
        typedef ListIterator<T, Ref, Ptr> Self;
        //构造
        ListIterator(PNode pNode = nullptr)
            :_pNode(pNode)
        {}
        //拷贝构造
        ListIterator(const Self& x)
        {
            _pNode = x._pNode;
        }
        //返回对节点数据的引用/const引用
        Ref operator*()
        {
            return _pNode->_val;
        }
        //返回节点数据的指针/const指针
        Ptr operator->()
        {
            return &_pNode->_val;
        }
        //前置++
        //ListNode<T>* PNode
        // //这个迭代器是一个节点指针
        //*this即ListNode<T>节点本身，this指向迭代器本身
        Self& operator++()
        {
            _pNode = _pNode->_pNext;
            return *this;
        }
        //后置++
        //返回拷贝
        Self operator++(int)
        {
            PNode _ptmp = _pNode;
            _pNode = _pNode->_pNext;
            return _ptmp;
        }
        PNode _pNode;
    };
 

4.3list成员函数（代码）

  //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;
    public:

        // List的构造
        list()
        {
            _pHead = new Node;
            _pHead->_pNext = _pHead;
            _pHead->_pPre = _pHead;
            _size = 0;
        }

        // List Iterator
        iterator begin()
        {
            iterator it;
            it._pNode = _pHead->_pNext;
            return it;
        }
        iterator end()
        {
            iterator it;
            it._pNode = _pHead;
            return it;
        }

        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 n_tmp = new Node;
            //pos的地址
            n_tmp->_pNext = pos._pNode;
            //pos上一个节点的地址
            n_tmp->_pPre =  pos._pNode->_pPre;
            n_tmp->_val = val;
            //pos节点的上一个节点的下一个节点地址
            pos._pNode->_pPre->_pNext = n_tmp;
            //pos节点的上一个节点地址
            pos._pNode->_pPre = n_tmp;
            ++_size;
            return n_tmp;
        }
    private:
        //节点指针
        PNode _pHead;
        int _size;
    };