链表类模板的实现

任务描述

本关任务：实现双向链表类模板。

相关知识

为了完成本关任务，你需要掌握：1.复习C语言链表的实现。2.对链表的数据属性和功能进行封装。3.利用模板实现数据类型的参数化。
主程序main()中定义通用算法如下：

1. template<class Iterator> //在指定范围内输出元素
   void display(Iterator first, Iterator last)
   {
   for (; first != last; ++first)
   cout << *first << ' ';
   cout << endl;
   }

该算法能够输出链表模板类对象中存放的元素。

编程要求

根据提示，在右侧编辑器补充代码，实现链表类模板的定义。

测试说明

平台会对你编写的代码进行测试：

预期输出：
109 108 107 106 105 104 103 102 101 100
108 107 106 105 104 103 102 101 100
108 107 106 105 104 103 102 101 100
38 36 34 32 30 28 26 24 22 20 18 16 14 12 10 8 6 4 2 0 108 107 106 105 104 103 102 101 100
36 34 32 30 28 26 24 22 20 18 16 14 12 10 8 6 4 2 0 108 107 106 105 104 103 102 101 100
36 34 32 30 28 26 24 22 20 18 16 14 12 10 8 6 4 2 0 108 107 106 105 104 103 102 101 100

 

#pragma once
template<class T>
class List
{
    protected:
    struct Node
    {
        T data;
        Node*prev;
        Node*next;
        Node(T d=0,Node*p=0,Node*n=0):data(d),prev(p),next(n){}
    };
    int size;
    Node*head;
    Node*tail;
    void Init()
    {
        size=0;head=new Node;tail=new Node;
        head->next=tail;
        tail->prev=head;
    }
    public:
    class iterator
    {
        public:
        Node*cur;
        T& get_value()
        {
           return cur->data;
        }
        iterator(Node* p):cur(p){}
        iterator():cur(0){}
        T& operator *()
        {
            return get_value();
        }
        iterator operator ++()
        {
            cur=cur->next;
            return *this;
        }
        iterator operator ++(int)
        {
            iterator old=*this;
            ++(*this);
            return old;
        }
        iterator operator --()
            {
                cur=cur->prev;
                return *this;
            }
        iterator operator --(int)
        {
            iterator old=*this;
            --(*this);
            return old;
        }
        bool operator ==(iterator& itr)
        {
            return cur==itr.cur;
        }
        bool operator !=(iterator& itr)
        {
            return cur!=itr.cur;
        }
    };
    public:
    List()
    {
        Init();  
    }
    List(List<T>& l)
    {
        Init();
        *this=l;
    }
    List<T>& operator=(List<T>&l);
    int Size()
    {
        return this->size;
    }
    iterator Begin()
    {
        return iterator(head->next);
    }
    iterator End()
    {
        return iterator(tail);
    }
    iterator Insert(iterator itr,T value);
    iterator Erase(iterator itr);
    void pop_front()
    {
        Erase(Begin());
    }
    void pop_back()
    {
        Erase(End());
    }
    void push_front(T& value)
    {
        Insert(Begin(),value);
    }
    void push_back(T& value)
    {
        Insert(End(),value);
    }
    void clear()
    {
        while(Size()!=0)pop_front();
    }
};


template<class T>
typename List<T>::iterator List<T>::Insert(iterator itr,T value)
{
    Node*p=itr.cur;
    p->prev->next=new Node(value,p->prev,p);
    p->prev=p->prev->next;
    size++;
    return iterator(p->prev);
}
template<typename T>
typename List<T>::iterator List<T>::Erase(iterator itr)
{
    Node*p=itr.cur;
    iterator ne(p->next);
    p->prev->next=p->next;
    p->next->prev=p->prev;
    size--;
    delete p;
    return ne;
}

template<typename T>
List<T>& List<T>::operator=(List<T>&l)
{
    this->clear();
    iterator first=l.Begin();
    iterator last=l.End();
    for (;first!=last;first++)
    {
        push_back(*first);
    }
    return *this;
}