List模拟实现

目录

基础模拟实现结构

1.节点类

2.迭代器类

2.1构造&拷贝构造

2.2operator重载

3.List类

3.1构造&拷贝构造&析构

3.2iterator

3.3insert&erase&clear

打印函数

---

基础模拟实现结构

首先还是模拟实现结构

namespace my_list
{
    //List节点类
    template<class T>
    struct ListNode
    {
        ListNode(const T& val = T());
        ListNode<T> _pPre;
        ListNode<T> _pNext;
        T _data;
    };

    template<class T,class Ref,class Ptr>//区分是否为const迭代器
    struct ListIterator
    {
        typedef ListNode<T> Node;
        typedef Node* PNode;
        typedef ListIterator<T,Ref,Ptr> Self;

        PNode _pNode;
        
        ListIterator(PNode pNode = nullptr);
        ListIterator(const Self& lit);
        T& operator*();
        T* operator->();
        Self& operator++();
        Self operator++(int);
        Self& operator--();
        Self& operator--(int);
        bool operator!=(const Self& lit);
        bool operator==(const Self& lit);
        
    };

    template<class T>
    struct List
    {
        typedef ListNode<T> Node;
        typedef Node* PNode;
    public:
        typedef ListIterator<T,T&,T*> iterator;
        tyoedef ListIterator<t,const T&, const T*> const_iterator;

        // List的构造
        list();
        list(int n, const T& value = T());
        template <class Iterator>
        list(Iterator first, Iterator last);
        list(const list<T>& l);
        list<T>& operator=(const list<T> l);
        ~list();

        // List Iterator
        iterator begin();
        iterator end();
        const_iterator begin();
        const_iterator end();

         // List Capacity
        size_t size()const;
        bool empty()const;

         // List Access
        T& front();
        const T& front()const;
        T& back();
        const T& back()const;

        // 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);

        // 删除pos位置的节点，返回该节点的下一个位置
        iterator erase(iterator pos);
        void clear();
        void swap(list<T>& l);

    private:
        PNode _head;
        size_t _size;//方便计算大小
    };
}

1.节点类

创建list的节点类用作每个节点，

template<class T>
    struct ListNode
    {
        ListNode<T> _pPre;//前一个节点的地址
        ListNode<T> _pNext;后一个节点的地址
        T _data;//节点储存的数据

        ListNode(const T& val = T())
        {
            _pPre = nullptr;
            _pNext = nullptr;
            _data = val;
        }
    };

2.迭代器类

2.1构造&拷贝构造

ListIterator(PNode pNode = nullptr)
{
    _pNode = pNode;
}   
    //或者使用初始化列表都可以

ListIterator(const Self& lit):_pNode(lit._pNode)
{}; 

2.2operator重载

Ref operator*()//注意有了Ref 和 Ptr,这里就要返回Ref（引用）
{
    //解引用符号重载
    return _pNode->_data;
}

Ptr operator->()
{
//AA* 第一个箭头取到AA* 第二个箭头解引用
//其实有两个箭头 it.operator->()->_data
    return &_pNode->_data;
}

Self& operator++(int)//前置++
{
    Self tmp(*this);//拷贝构造当前Self
    _pNode = _pNode->_pNext;
    return tmp;
}

Self& operator++()
{
    _pNode = _pNode->pNext;
    return *this;
}

Self& operator--()
{
    _pNode = _pNode->pPre;
    return *this;
}

Self& operator--(int)
{
    Self tmp(*this)；
    _pNode = _pNode->pPre;
    return tmp;
}

bool operator!=(const Self& lit)
{
    return _pNode != lit._pNode;
}

bool operator==(const Self& lit)
{
    return !(lit!=*this);
}

3.List类

3.1构造&拷贝构造&析构

void empty_init()
{
    _head = new Node;
    _head->_pNext = _head;
    _head->_pPre = _head;
    _size = 0;
}

list()
{    
    empty_init();//初始化哨兵位节点
}

list(int n, const T& value = T())
{
    empty_init();
    while(n--)
        push_back(value);
}

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

//list是有自己的地址所以要深拷贝   
list(const list<T>& l)
{
    empty_init();

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

void swap(list<T>)
{
    std::swap(_head, l._head);
    std::swap(_size, l._size);
}

list<T>& operator=(const list<T> l)
{
    swap(l);

    return *this;
}

~list()
{
    clear();
    
    delete _head;
    _head = nullptr;
}

3.2iterator

iterator begin()
{
    return _head->_pNext;    
}

iterator end()
{
    return _head;
}

const_iterator begin() const
{
    return _head->_pNext;    
}

const_iterator end() const
{
    return _head;
}

3.3insert&erase&clear

//push_back等都是由insert和erase实现

// 在pos位置前插入值为val的节点
iterator insert(iterator pos, const T& val)
{
    //pos是迭代器类，访问节点要用.操作符
    PNode newnode = new Node(val);
    PNode pCur = pos._pNode;
    newnode->pNext = pCur;
    newnode->pPre = pCur->pPre;
    pCur->pPre->pNext = newnode;
    pCur->pPre = newnode;
    ++_size;

    return iterator(newnode);
}

// 删除pos位置的节点，返回该节点的下一个位置
iterator erase(iterator pos)
{
    PNode pCur = pos._pNode;
    pNode next = pCur->_pNext;
    pCur->_pPre->_pNext = pCur->_pNext;
    pCur->_pNext->_pPre = pCur->_pPre;
    
    --_size();
    delete pCur//销毁

    return iterator(next);
}

void clear()
{
    iterator it = begin();
    while (it != end())
    {
	    it = erase(it);
    }
    _phead->pNext = _phead;
    _phead->pPre = _phead;
}

打印函数

template<class Container>
void print_Container(const Container& cont)
{
    for(auto e: cont)
    {
        cout << e << " ";
    }
    cout << endl;
}