顺序表的问题

谢谢kai，我知道那里错了，我会进一步改进程序的

#include <iostream>
#include <cstdlib>
using namespace std;

template<class Elem>
class List
{
//Renitialize the list. The client is responsible for
//reclaiming the storage used by the list elements.
virtual void clear()=0;
//Insert an element at the front of the right partition
//Return true if successfull,false if the list if full.
virtual bool insert(const Elem &)=0;
//Append an element at the end of the right partition.Return
//true if successful,false if the list if full.
virtual bool append(const Elem &)=0;
//Remove the first element of the right partition.Return true
//if seccessful,false if the right partition is empty.
//The element removed is returned in the parameter.
virtual bool remove(Elem &)=0;
//Place fence at list start,making left partition empty.
virtual void setStart()=0;
//Place fence at list end,making right partition empty.
virtual void setEnd()=0;
//Move fence one step left;no change if already at start
virtual void prev()=0;
//Move fence one step right;no change if already at end
virtual void next()=0;
//Return length of left partition
virtual int leftLength() const=0;
//Return length of right partition
virtual int rightLength() const=0;
//If pos and more elements are in the list,set the size of left partition
//to pos and return true.Otherwise,do nothing and return false.
virtual bool setPos(int pos)=0;
//Return in first parameter the first element of the right partition.
//Return true if successful,flase if the right partition is empty.
virtual bool getValue(Elem&) const=0;
//Print the contents of the list
virtual void print() const=0;
};

template<class Elem>
class Link
{
public:
  Elem element;
  Link * next;
  Link(const Elem & elemval, Link * nextval = NULL)
  {
     element = elemval;
     next = nextval;
  }
  Link(Link * nextval = NULL)
  {
     next = nextval;
  }
};

template<class Elem>
class LList : public List<Elem>
{
private:
   Link<Elem> * head;
   Link<Elem> * tail;
   Link<Elem> * fence;
   int left_length;
   int right_length;
   void init()
   {
      fence = head = tail = new Link<Elem>;
      left_length = right_length = 0;
   }
   void removeall()
   {   //Return link nodes to free store
      while(head != NULL)
      {
         fence = head;
         head = head->next;
         delete fence;
      }
   }
public:
   LList(int size = 10)
   {
      init();
   }
   ~LList()
   {
      removeall();
   }
   void clear()
   {
      removeall();
      init();
   }
   bool insert(const Elem & );
   bool append(const Elem & );
   bool remove(Elem &);
   void setStart()
   {  
      fence = head;
      right_length += left_length;
      left_length=0;
   }
   void setEnd()
   {  
      fence = tail;
      left_length += right_length;
      right_length = 0;
   }
   void prev();
   void  next()
   {
      if(fence != tail)
      {
         fence = fence->next;
         right_length--;
         left_length++;
      }
   }
   int leftLength() const
   {
      return left_length;
   }
   int rightLength() const
   {
      return right_length;
   }
   bool setPos(int pos);
   bool getValue(Elem & it) const
   {
      if(rightLength() == 0)
         return false;
      it = fence->next->element;
      return true;
   }
   void print() const;
};

template<class Elem>
bool LList<Elem>::insert(const Elem & item)
{
   fence->next = new Link<Elem>(item,fence->next);
   if(tail == fence)  
      tail = fence->next;
   right_length++;
   return true;
}
template<class Elem>
bool LList<Elem>::append(const Elem& item)
{
   tail = tail->next = new Link<Elem>(item, NULL);
   right_length++;
   return true;
}

template<class Elem>
bool LList<Elem>::remove(Elem & it)
{
   if(fence->next == NULL)
      return false;
   it = fence->next->element;
   Link<Elem> * ltemp = fence->next;
   fence->next = ltemp->next;
   if(ltemp == tail)
      tail = fence;
   delete ltemp;
   right_length--;
   return true;
}
template<class Elem>
void LList<Elem>::prev()
{
   Link<Elem> * temp = head;
   if(fence == head)
      return;
   while(temp->next != fence)
      temp = temp->next;
   fence = temp;
   left_length--;
   right_length++;
}

template<class Elem>
bool LList<Elem>::setPos(int pos)
{
   if(pos<0 || pos > right_length + left_length)
      return false;
   fence = head;
   for(int i = 0; i < pos; pos++)
      fence = fence->next;
   return true;
}

template<class Elem>
void LList<Elem>::print() const
{
   Link<Elem> * temp = head;
   cout<<"<";
   while(temp != fence)
   {
      cout<<temp->next->element<<" ";
      temp = temp->next;
   }
   cout<<"|";
   while(temp->next != NULL)
   {
      cout<<temp->next->element<<" ";
      temp = temp->next;
   }
   cout<<">\n";
}

int main()
{
   int A[10] = {1,2,3,4,5,6,7,8,9,10};
   LList<int> list;
   for(int i=0; i<10; i++)
      list.append(A[i]);
//   list.setPos(5);         // 帮你整理了一下程序，如果隐去这一行，至少还能打印
                                  // 也就是说，你的程序有逻辑错误，对地址操作有误。
   list.print();
   system("pause");
   return EXIT_SUCCESS;
}

// 我通看了你的代码， 不理解你为什么需要 fence 这个变量。也不理解 left_length 和 right_length 的用途。
// 在一个class 的定义中，一旦有成员变量为 地址变量, 即  Type * a_address; 那么你需要写 copyconstructor function, 以及 assigment function ,  以防止浅Copy 的出现.

你在程序中写了 init()  以及 removeall() 函数，我觉得没有必要，可以直接写  constructor function 以及 destructor function.

一个list 是这样一个概念, list 是用于存放其他 object 的一个object. 而每一个object 是上下手牵手连着的.
那么它的class 定义看起来是这样的:

class List
{
template <class Type>
struct Otherobject
{
   Type value;
   Otherobject * prev;
   Otherobject * next;
}
private:
   Otherobject * poo;   // address of the first element
   intsize;                   // current size;
   intcapability;          // the max size, it must be larger than size, and a list can beextendable.
   bool operator<(const Otherobject & oo1, const Otherobject & oo2);
public:
   List();    // default constructor
   List(Otherobject * begin, Otherobject * end);   // constructor
   List(const int size);   // constructor
   List(const List & otherList);   // copy constructor
   List & operator=(const List & L);   // assignment
   void push_front(const T & t);   // inserts an element at the beginning
   void pop_front();   // deletes the first element
   void push_back(const T & t);   // inserts an element at the end
   void pop_back();  // deletes the last element
   void remove(const T & t);  // removes all elements that are equal to the passed element t
   void reverse();   // reversers the order of elements in the list
   void sort();  // sorts the elements in the list. Thesorting criterion is <operator defined for the elements
  Otheobject * insert(Otherobject * pos, const Otherobject &oo);  // inserts a copy of  oo  before pos, returnan   iterator(point) pointing to the inserted copy of oo
   void print();
   // and so on...
};

我发现错误所在呢，我真是粗心啊。
template<class Elem>
bool LList<Elem>::setPos(int pos)
{
   if(pos<0 || pos > right_length + left_length)
      return false;
   fence = head;
   for(int i = 0; i < pos; pos++)            //应该是for(int i=0;i<pos;i++)

      fence = fence->next;
   return true;
}

这回没问题了，我觉得逻辑上还是没有错误的：
#include <iostream>
#include <cstdlib>
using namespace std;

template<class Elem>
class List
{
//Renitialize the list. The client is responsible for
//reclaiming the storage used by the list elements.
virtual void clear()=0;
//Insert an element at the front of the right partition
//Return true if successfull,false if the list if full.
virtual bool insert(const Elem &)=0;
//Append an element at the end of the right partition.Return
//true if successful,false if the list if full.
virtual bool append(const Elem &)=0;
//Remove the first element of the right partition.Return true
//if seccessful,false if the right partition is empty.
//The element removed is returned in the parameter.
virtual bool remove(Elem &)=0;
//Place fence at list start,making left partition empty.
virtual void setStart()=0;
//Place fence at list end,making right partition empty.
virtual void setEnd()=0;
//Move fence one step left;no change if already at start
virtual void prev()=0;
//Move fence one step right;no change if already at end
virtual void next()=0;
//Return length of left partition
virtual int leftLength() const=0;
//Return length of right partition
virtual int rightLength() const=0;
//If pos and more elements are in the list,set the size of left partition
//to pos and return true.Otherwise,do nothing and return false.
virtual bool setPos(int pos)=0;
//Return in first parameter the first element of the right partition.
//Return true if successful,flase if the right partition is empty.
virtual bool getValue(Elem&) const=0;
//Print the contents of the list
virtual void print() const=0;
};

template<class Elem>
class Link
{
public:
  Elem element;
  Link * next;
  Link(const Elem & elemval, Link * nextval = NULL)
  {
     element = elemval;
     next = nextval;
  }
  Link(Link * nextval = NULL)
  {
     next = nextval;
  }
};

template<class Elem>
class LList : public List<Elem>
{
private:
   Link<Elem> * head;
   Link<Elem> * tail;
   Link<Elem> * fence;
   int left_length;
   int right_length;
   void init()
   {
      fence = head = tail = new Link<Elem>;
      left_length = right_length = 0;
   }
   void removeall()
   {   //Return link nodes to free store
      while(head != NULL)
      {
         fence = head;
         head = head->next;
         delete fence;
      }
   }
public:
   LList(int size = 10)
   {
      init();
   }
   ~LList()
   {
      removeall();
   }
   void clear()
   {
      removeall();
      init();
   }
   bool insert(const Elem & );
   bool append(const Elem & );
   bool remove(Elem &);
   void setStart()
   {  
      fence = head;
      right_length += left_length;
      left_length=0;
   }
   void setEnd()
   {  
      fence = tail;
      left_length += right_length;
      right_length = 0;
   }
   void prev();
   void  next()
   {
      if(fence != tail)
      {
         fence = fence->next;
         right_length--;
         left_length++;
      }
   }
   int leftLength() const
   {
      return left_length;
   }
   int rightLength() const
   {
      return right_length;
   }
   bool setPos(int pos);
   bool getValue(Elem & it) const
   {
      if(rightLength() == 0)
         return false;
      it = fence->next->element;
      return true;
   }
   void print() const;
};

template<class Elem>
bool LList<Elem>::insert(const Elem & item)
{
   fence->next = new Link<Elem>(item,fence->next);
   if(tail == fence)  
      tail = fence->next;
   right_length++;
   return true;
}
template<class Elem>
bool LList<Elem>::append(const Elem& item)
{
   tail = tail->next = new Link<Elem>(item, NULL);
   right_length++;
   return true;
}

template<class Elem>
bool LList<Elem>::remove(Elem & it)
{
   if(fence->next == NULL)
      return false;
   it = fence->next->element;
   Link<Elem> * ltemp = fence->next;
   fence->next = ltemp->next;
   if(ltemp == tail)
      tail = fence;
   delete ltemp;
   right_length--;
   return true;
}
template<class Elem>
void LList<Elem>::prev()
{
   Link<Elem> * temp = head;
   if(fence == head)
      return;
   while(temp->next != fence)
      temp = temp->next;
   fence = temp;
   left_length--;
   right_length++;
}

template<class Elem>
bool LList<Elem>::setPos(int pos)
{
   if(pos<0 || pos > right_length + left_length)
      return false;
   fence = head;
   for(int i = 0; i < pos; i++)
      fence = fence->next;
   return true;
}

template<class Elem>
void LList<Elem>::print() const
{
   Link<Elem> * temp = head;
   cout<<"<";
   while(temp != fence)
   {
      cout<<temp->next->element<<" ";
      temp = temp->next;
   }
   cout<<"|";
   while(temp->next != NULL)
   {
      cout<<temp->next->element<<" ";
      temp = temp->next;
   }
   cout<<">\n";
}

int main()
{
   int A[10] = {1,2,3,4,5,6,7,8,9,10};
   LList<int> list;
   for(int i=0; i<10; i++)
      list.append(A[i]);
   list.setPos(5);         //现在没问题了
                                 
   list.print();
   system("pause");
   return EXIT_SUCCESS;
}

恩，同意。一下子就让我设计类，根本不知道应该有什么方法，哪些功能在哪些类里实现。哪些类继承就可以。