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;
}