#pragma once; #include <assert.h> #include<iostream> #include <assert.h> using namespace std; template<class T> struct __ListNode {    T _data;    __ListNode<T>* _next;    __ListNode<T>* _prev;    __ListNode(const T& x)      :_data(x)      ,_next(NULL)      ,_prev(NULL)    {    } }; template <class T,class Ref,class Ptr > struct __ListIterator {   typedef __ListNode<T>  Node;   typedef __ListIterator<T,Ref,Ptr> Self; __ListIterator(Node* node)       :_node(node)   {   }   Ref operator*()   {     return _node->_data;   }   Ptr operator->()   {     return &(_node->_data)   }   Self& operator++()   {     _node=_node->_next;     return *this;   }   Self& operator--()   {     _node=_node->_prev;     return *this;   }   Self operator++(int)   {     Self tmp=_node;     _node=_node->_next;     //return tmp;     return Self(tmp)     }   Self operator--(int)   {       Self tmp=(*this);     _node=_node->_prev;     return tmp;   }   bool operator!=(const Self& s) const   {    return this->_node!=s._node;   }   bool operator==(const Self& s) const   {     return this->_node==s._node;   }   Node* _node; }; template<class T> struct List {   typedef __ListNode<T> Node; public:   typedef __ListIterator<T,T&,T*> Iterator;   typedef __ListIterator<T,const T&,const T*> ConstIterator;   Node* GetNode(const T& x)   {     return new Node(x);   }   List()   {     _head=GetNode(T());     _head->_next=_head;     _head->_prev=_head;   }   Iterator Begin()   {    return Iterator(_head->_next);   }   Iterator End()   {    return Iterator(_head);   }   ConstIterator Begin() const   {     return ConstIterator(_head->_next);   }   ConstIterator End() const   {     return ConstIterator(_head);   }       void PushBack(const T& x)   {    /* Node* _tail=_head->_prev;     Node* tmp=GetNode(x);     _tail->_next=tmp;     tmp->_prev=_tail;     tmp->_next=_head;     _head->_prev=tmp;*/     Insert(End(),x);   }  void PopBack()  {    /* assert(_head->_prev );    Node* tail=_head->_prev;    Node* prev=tail->_prev;    Node* next=tail->_next;    prev->_next=next;    next->_prev=prev;    delete tail;*/    Erase(--End());  }  void PushFront(const T& x)  {   /*assert(_head)    Node* tmp=GetNode(x);    Node* next=_head->_next;     _head->_next=tmp;    tmp->_prev=_head;     tmp->_next=next;     next->_prev=tmp;*/    Insert(Begin(),x);  }  void PopFront()  {    /*assert(_head->_next);    Node* tmp=_head->_next;    Node* next=tmp->_next;     _head->_next= next;    next->_prev=_head;    delete tmp;*/      Erase(Begin());  }  Iterator Insert(Iterator pos, const T& x)  {    assert(pos._node);    Node* tmp=GetNode(x);    Node* cur=pos._node;    Node* prev=cur->_prev;         prev->_next=tmp;    tmp->_prev=prev;    tmp->_next=cur;    cur->_prev=tmp;    return tmp;  }  Iterator Erase(Iterator pos) { assert(pos._node && pos._node!=NULL); Node* tmp=pos._node; Node* next=tmp->_next; Node* prev=tmp->_prev;   next->_prev=prev; prev->_next=next;  delete tmp; return Iterator(next); }   protected:   Node* _head; }; void PrintList(const List<int>& l) {   List<int>::ConstIterator It=l.Begin();   while(It!=l.End())   {      cout<<*It<<" ";     ++It;   }   cout<<endl;}  void TestList2() {   List<int> l2;      l2.PushBack(1);    l2.PushBack(2);   l2.PushBack(3);   l2.PushBack(4);   l2.PopBack();    l2.PopBack();     l2.PopBack();     l2.PopBack();      l2.PopBack();    PrintList(l2); } void TestList3() {   List<int> l3;   l3.PushFront(1);   l3.PushFront(2);   l3.PushFront(3);   l3.PushFront(4);   l3.PopFront();   l3.PopFront();   l3.PopFront();   PrintList(l3);   } 

#include "List.h"  int main() {   //TestList1();    //TestList2();    TestList3();    return 0; }