以前寫過用C語言實現的順序表，現在來看看用C++類實現的吧

class SeqList
{
public:
	SeqList(int capacity=DEFAULT_CAPACITY)
		:_capacity(capacity)
		,_size(0)
		,_pData(0)
	{
		_pData=new DataType[_capacity];
	}

	~SeqList()
	{
		if(_pData!=NULL)
		{
			delete[] _pData;
		}
	}

	SeqList(const SeqList& s)
		:_size(s._size)
		,_capacity(s._capacity)
	{
		_pData=new DataType[_capacity];
		memcpy(_pData,s._pData,_size*sizeof(DataType));
	}

	SeqList& operator=(const SeqList& s)
	{
		if(this != &s)
		{
			delete[] _pData;
			_pData=new DataType[s._capacity];
			memcpy(_pData,s._pData,s._size*sizeof(DataType));
			_size=s._size;
			_capacity=s._capacity;
		}
		return *this;
	}

	void PushBack(const DataType& d)
	{
		_CheckCapacity();
		_pData[_size++]=d;
	}

	void PushFront(const DataType& d)
	{
		_CheckCapacity();
		int start=_size-1;
		while(start>=0)
		{
			_pData[start+1]=_pData[start];
			start--;
		}
		_pData[0]=d;
		_size++;
	}

	void PopBack()
	{
		if(_pData!=NULL)
		{
			_pData[_size--];
		}
	}

	void PopFront()
	{
		if(_pData!=NULL)
		{
			for(int i=0; i<_size-1; i++)
			{
				_pData[i]=_pData[i+1];
			}
			_size--;
		}
	}

	DataType& operator[](int index)
	{
		return ( _pData[index]);
	}

	int Find( const DataType& d)
	{
		int i=0;
		for(i=0; i<_size-1; i++ )
		{
			if(_pData[i]==d)
			{
				return i;
			}
		}
		return -1;
	}

	void Insert(int pos,const DataType& d)
	{
		assert(pos>=0 && pos<_size);
		int move=_size-pos;
		int end=_size;
		_CheckCapacity();
		while(move--)
		{
			_pData[end]=_pData[end-1];
			end--;
		}
		_pData[pos]=d;
		_size++;
	}

	void Remove(const DataType& d)
	{
		int pos=Find(d);
		int i=0;
		if(pos!=-1)
		{
			for(i=pos; i<_size-1; i++)
			{
				_pData[i]=_pData[i+1];
			}
			_size--;
		}
	}

	void Reverse()
	{
		int left=0;
		int right=_size-1;
		while(left<right)
		{
			DataType tmp=_pData[left];
			_pData[left]=_pData[right];
			_pData[right]=tmp;
			left++;
			right--;
		}
	}

	friend ostream& operator<<(ostream& os,const SeqList& s);


private:
	int _capacity; //線性表容量
	int _size;    //所含資料個數
	DataType *_pData;
	void _CheckCapacity()
	{
		if(_size==_capacity)
		{
			DataType *tmp=new DataType[_capacity+DEFAULT_CAPACITY ];
			memcpy(tmp,_pData,_size*sizeof(DataType));
			delete[] _pData;
			_pData=tmp;
			_capacity=_capacity+DEFAULT_CAPACITY ;
		}
	}

};

ostream& operator<<(ostream& os,const SeqList& s)
{
	int i=0;
	for(i=0; i<s._size; i++)
	{
		os<<s._pData[i]<<' ';
	}
	os<<endl;
 return os;
}