list模拟实现

模拟实现

代码

#pragma once


// List的节点类
template
struct ListNode
{
    ListNode(const T& val = T())
        :_pPre(nullptr)
        ,_pNext(nullptr)
        ,_val(val)
    { }
    ListNode* _pPre;
    ListNode* _pNext;
    T _val;
};


//List的迭代器类
template
class ListIterator
{
    typedef ListNode* PNode;
    typedef ListIterator Self;
public:
    ListIterator(PNode pNode = nullptr)
        :_pNode(PNode)
    {

    }

    ListIterator(const Self& l)
        :_pNode(l._pNode)
    {

    }

    T& operator*()
    {
        return _pNode->_val;
    }

    T* operator->()
    {
        return &_pNode->_val;
    }

    Self& operator++()
    {
        return _pNode->_pNext;
    }

    Self operator++(int)
    {
        Self tmp(*this);
        _pNode = _pNode->_pNext;
        return tmp;
    }

    Self& operator--()
    {
        return _pNode->_pPre;
    }

    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)
    {
        return _pNode == l._pNode;
    }

private:
    PNode _pNode;
};


//list类
template
class list
{
    typedef ListNode Node;
    typedef Node* PNode;

public:
    typedef ListIterator iterator;

    typedef ListIterator const_iterator;
public:
    ///
    // List的构造
    list()
    {
        CreateHead();
    }

    list(int n, const T& value = T())
    {
        CreateHead();

        for (int i = 0; i < n; i++)
        {
            push_back(value);
        }
    }

    template 
    list(Iterator first, Iterator last)
    {
        while (first != last)
        {
            push_back(*first);
            first++;
        }
    }

    list(const list& l)
    {
        CreateHead();
        for (auto& e : l)
        {
            push_back(e);
        }
    }

    list& operator=(const list l)
    {
        swap(l);

        return *this;
    }

    ~list()
    {
        clear();

        delete _pHead;
        _pHead = nullptr;
    }


    ///
    // List Iterator
    iterator begin()
    {
        return iterator(_pHead->_pNex);
    }

    iterator end()
    {
        return iterator(_pHead);
    }

    const_iterator begin()
    {
        return const_iterator(_pHead->_pNex);
    }

    const_iterator end()
    {
        return const_iterator(_pHead);
    }


    ///
    // List Capacity
    size_t size()const
    {
        return _size;
    }

    bool empty()const
    {
        return _size == 0;
    }


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

    const T& front()const
    {
        return _pHead->_pNext->_val;
    }

    T& back()
    {
        return _pHead->_pPre->_val;
    }

    const T& back()const
    {
        return _pHead->_pPre->_val;
    }


    
    // 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)
    {
        Node* cur = pos._pNode;
        Node* pre = cur->_pPre;

        Node* newnode = new Node(val);

        pre->_pNext = newnode;
        newnode->_pPre = pre;

        cur->_pPre = newnode;
        newnode->_pNext = cur;

        _size++;
    }
    // 删除pos位置的节点，返回该节点的下一个位置
    iterator erase(iterator pos)
    {
        Node* cur = pos._pNode;
        Node* pre = cur->_pPre;
        Node* next = cur->_pNext;

        delete cur;

        pre->_pNext = next;
        next->_pPre = pre;

        _size--;
    }

    void clear()
    {
        auto it = begin();
        while (it != end())
        {
            erase(it);   //返回下一个位置
        }

        _size = 0;
    }

    void swap(list& l)
    {
        std::swap(_pHead, l._pHead);
        std::swap(_size, l._size);
    }

private:

    void CreateHead()
    {
        _pHead = new Node;
        _pHead->_pNext = _pHead;
        _pHead->_pPre = _pHead;
    }

    PNode _pHead;

    size_t _size;
};