C++实现List类

考虑到设计需要，我们需要提供下面的4个类:
(1)List类本身。它包含连接到两端的链接，表的大小以及一系列方法。
(2)Node类。该类看起来是私有的嵌套类。一个节点包含数据和用来指向其前和其后的结点的指针，以及适当的构造函数。
(3)const_iterator类。该类抽象了位置的概念。
(4)iterator类。

template <typename Object>
class List
{
  private:
    struct Node
        {    };
  public:
      class const_iterator {   };
      class iterator:public const_iterator{  };
  public:
      List()
      {                  }
      List(cosnt List & rhs)
      {                    }
      ~List()  {               }
      const List & operator= (const List & rhs)
      {                 }
      iterator begin()
      { return iterator(head->next);}
      const_iterator begin() const 
      { return const_iterator(head->next); }
      iterator end()
      {  return iterator( tail);}
      const_iterator end() const
        {retrun const_iterator(tail); }

      int size()
      {  return theSize;}
      bool empty( ) const
      {  return size() == 0; }
      void clear()
      {
         while(!empty())
             por_front( );
      }
      Object & front()
      { retrun *begin();}
      const Object & front()   const
      { return *begin();}
      Object & back()
       { return *--end(); }
      const Object & back() const
        {  return 8--end(); }
      void push_front(const Object* x)
      {  insert(begin(),x);}
      void push_back(const Obect & x)
      { insert(end(),x); }
      void pop_front( )
         { erase(begin()):}
     void pop_back()
     {  erase(--end()); }
     iterator insert( iterator itr,const Object & x)
     {          }
     iterator erase(iterator itr)
     {     }
     iterator erase(iterator start, iterator end)
     {     }
 private:
      int theSize;
      Node * head;
      Node * tail;
      void init()
        {     }
};

Node 类

struct Node
{
      Object data;
      Node *prev;
      Node
      Node（const Obejct & d=Object(),Node *p=NULL,Node *n=NULL):data(d),prev(p),next(n){}
};

常迭代器类
治理要注意一下operator++的实现。在语法上前缀和后缀版本的operator++是完全不同的。因此，需要对不同的形式分别来编写例程。他们拥有相同的名字，因此必须用不同的符号来区分。C++需要通过给前缀形式指定空参数表，给后缀形式指定一个匿名的int参数来富裕前缀和后缀形式以不同的标识。然后，++itr掉头、用另参数operator++;而itr++调用单参数operator++。这个int参数永远也不使用，其存在的意义仅仅在于给出一个不同的标识，使用前缀的形式要快于使用后缀的形式。

class const_iterator
{
  publicL
    const_iterator( ):current(NULL)
    {  }
   const Obejct & operator* ( ) const
     { return retieve(); }
   const_iterator & operator++ ( )
   {
      current=current->next;
      retrun *this;
   }
   iterator operator++(int )
   {
       iterator old=*this;
       ++(*this);
       return old;
   }
protected:
   iterator(Node *p):const_iterator(p){  }
   friend class List<Object>;
};

iterator类 他继承自const_iterator

class iterator:public const_iterator
{
    public:
      iterator()  { }
    object & operator*( )
    {   return retrieve(); }
    const Object & operator *( ) const
        { return const_iterator::operator*(); }
    iterator & operator++()
    {
       current=current->next;
       return *this;
    }
    iterator operator++(int)
    {
       iterator old=*this;
       ++(*this):
       return old;
    }
    protected:
      iterator(Node*p) : const_iterator(p)
      {}
      friend class List<Object>;
};

List类的构造函数，三大函数和私有init例程

List()
   { init() ; }
~List()
{
    clear();
    delete head;
    delete tail;
}
List(const List & rhs)
{
   init();
   *this=rhs;
}

cosnt List & operator= (const List & rhs )
{
   if( this == &rhs)
      retrun *this;
   clear();
   for(const_iterator itr=rhs.begin();itr !=rhs.end();++itr)
      push_back( *itr);
   return *this;
}

void init()
{
   thsSize=0;
   head=new Node;
   tail=new Node;
   head->next=tail;
   tail->prev=head;
}