《数据结构与算法分析C++描述(第3版)》第三章List容器可编译运行版

作者源代码有点问题，迭代器没定义--操作符，一些接口没考虑空链表的情况，以下是我修改后的可编译运行版本。

#include <assert.h>
#define NULL 0

template <typename Object>
class List
{
private:
 struct Node
 {
  Object  data;
  Node   *prev;
  Node   *next;

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

public:
 class const_iterator
 {
 public:
  const_iterator() : theList(NULL), current(NULL)
  { }

  const Object & operator* () const
  {
   return retrieve();
  }

  const_iterator & operator++ ()
  {
   current = current->next;
   return *this;
  }

  const_iterator operator++ (int)
  {
   const_iterator old = *this;
   ++(*this);
   return old;
  }

  bool operator== (const const_iterator & rhs) const
  {
   rhs.assertIsValid();
   if (rhs.theList != theList)
    return false;// throw IteratorMismatchException();

   return current == rhs.current;
  }
  bool operator!= (const const_iterator & rhs) const
  {
   return !(*this == rhs);
  }

 protected:
  Node *current;
  const List<Object> *theList;

  Object & retrieve() const
  {
   return current->data;
  }

  const_iterator(const List<Object> & lst, Node *p)
   : theList(&lst), current(p)
  {
  }

  void assertIsValid() const
  {
   //if (theList == NULL || current == NULL || current == theList->head)
   // throw IteratorOutOfBoundsException();
   assert(theList != NULL && current != NULL && current != theList->head);
  }

  friend class List<Object>;
 };

 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(const List<Object> & lst, Node *p) : const_iterator(lst, p)
  { }

  friend class List<Object>;
 };

public:
 List()
 {
  init();
 }

 ~List()
 {
  clear();
  delete head;
  delete tail;
 }

 List(const List & rhs)
 {
  init();
  *this = rhs;
 }

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

 iterator begin()
 {
  return iterator(*this, head->next);
 }
 const_iterator begin() const
 {
  return const_iterator(*this, head->next);
 }
 iterator end()
 {
  return iterator(*this, tail);
 }
 const_iterator end() const
 {
  return const_iterator(*this, tail);
 }

 int size() const
 {
  return theSize;
 }
 bool empty() const
 {
  return size() == 0;
 }

 void clear()
 {
  while (!empty())
   pop_front();
 }
 Object & front()
 {
  return *begin();
 }
 const Object & front() const
 {
  return *begin();
 }
 Object & back()
 {
  if (empty())
   return front();

  return *iterator(*this, tail->prev);
 }
 const Object & back() const
 {
  if (empty())
   return front();

  return *const_iterator(*this, tail->prev);
 }
 void push_front(const Object & x)
 {
  insert(begin(), x);
 }
 void push_back(const Object & x)
 {
  insert(end(), x);
 }
 void pop_front()
 {
  erase(begin());
 }
 void pop_back()
 {
  erase(iterator(*this, tail->prev));
 }

 iterator insert(iterator itr, const Object & x)
 {
  itr.assertIsValid();
  if (itr.theList != this)
   ;// throw IteratorMismatchException();

  Node *p = itr.current;
  theSize++;
  return iterator(*this, p->prev = p->prev->next = new Node(x, p->prev, p));
 }

 // Erase item at itr.
 iterator erase(iterator itr)
 {
  if (empty())
   return end();

  itr.assertIsValid();
  if (itr.theList != this)
   ;// throw IteratorMismatchException();

  Node *p = itr.current;
  iterator retVal(*this, p->next);
  p->prev->next = p->next;
  p->next->prev = p->prev;
  delete p;
  theSize--;

  return retVal;
 }

 iterator erase(iterator from, iterator to)
 {
  for (iterator itr = from; itr != to;)
   itr = erase(itr);

  return to;
 }

private:
 int   theSize;
 Node *head;
 Node *tail;

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

int main()
{
 List<int> list;
 list.push_back(1);
 list.pop_back();
 return 0;
}