C++之顺序表

顺序表的实现 

#define _CRT_SECURE_NO_WARNINGS 

#include<iostream>
#include<string.h>
#include<assert.h>
using namespace std;
typedef int DataType;
class SeqList
{
  public:

SeqList();
SeqList(DataType arr[], size_t size);
SeqList(const SeqList& d);
SeqList& operator=(const SeqList& s);
~SeqList();


public:
void PushBack(const DataType& d);
void PopBack();
void Insert(size_t pos, const DataType& d);
void Erase(size_t pos);
bool Empty()const;
size_t Size()const;
size_t Capacity()const;
DataType& operator[](size_t index);
const DataType& operator[](size_t index)const;
DataType& Front();
const DataType& Front()const;
DataType& Back();
const DataType& Back()const;
int Find(const DataType& d);
void Clear();


private:
void _CheckCapacity()
  {  
        if(_size >= _capacity)  
        {  
            DataType *newspace = new DataType[2*_capacity];  
            size_t i = 0;  
            for(i=0; i<_size; i++)  
            {  
                newspace[i] = _pArr[i];  
            }  
  
            delete []_pArr;  
            _pArr = NULL;  
            _pArr = newspace;  
            _capacity *= 2;  
        }  
    }


private:
size_t _size;    //

　　size的意思是大小，此方法是返回该vector对象当前有多少个元素。

size_t _capacity; //

capacity的意思是容量，此方法返回的是该vector对象最多能容纳多少个元素。

DataType* _pArr;
};
SeqList::SeqList()   //普通构造函数
     :_size(0)  
    ,_capacity(3)  
    ,_pArr(new DataType[_capacity])  
{} 
SeqList::SeqList(DataType arr[], size_t size)//数组构造函数
    :_size(size)  
    ,_capacity(size)  
    ,_pArr(new DataType[size])
{
    memcpy(_pArr,arr,size*sizeof(DataType));  //三个参数 目标参数 源参 字节大小
}
SeqList::SeqList(const SeqList& d)   //普通拷贝构造函数
    :_pArr(new DataType[d._capacity])  
    ,_capacity(d._capacity)  
    ,_size(d._size)  
{  
    size_t i = 0;  
    for(i=0; i<_size; i++)  
    {  
        _pArr[i] = d._pArr[i];  
    }  
};  
SeqList& SeqList::operator=(const SeqList& s) //普通赋值运算重载
{  
    if(this != &s)  
    {  
        DataType* temp = _pArr;//保存原地址  
        _pArr = new DataType[s._capacity];  
        _size = s._size;  
        _capacity = s._capacity;  
        delete []temp;  
        size_t i = 0;  
        for(i=0; i<s._size; i++)  
        {  
            _pArr[i] = s._pArr[i];  
        }  
    }  
      
    return *this;  
}  
SeqList::~SeqList()  //析构函数
{  
    if(NULL != _pArr)  
    {  
        delete []_pArr;  
        _pArr = NULL;  
        _capacity = 0;  
        _size = 0;  
    }  
}  
void SeqList::PushBack(const DataType& d)//尾插法
{  
    assert(_pArr);  
    _CheckCapacity();  
    _pArr[_size] = d;  
    _size++;  
}  
void SeqList::PopBack()//头插
{
   assert(_pArr);  
    if(Empty())  
    {  
        assert(false);  
        return;  
    }  
    _size--; 


}
void SeqList::Insert(size_t pos, const DataType& d)  //插入在pos之后插入d
{
    assert(pos>=0 && pos<_size);  
    _CheckCapacity();  
    size_t i = 0;  
    for(i=_size; i>pos; i--)  
    {  
        _pArr[i] = _pArr[i-1];  
    }  
    _pArr[pos] = d;  
    _size++;


}
void SeqList:: Erase(size_t pos)  //删除第pos个元素
{
    assert(pos >=0&&pos<_size);
if(_size == 0)
return ;
else 
{
  size_t i = 0;
  for(i=pos;i<_size-1;i++)
  {
  _pArr[i] = _pArr[i+1];
  }
  _size--;
}
}
bool SeqList:: Empty()const  //置空
{
   return _size == 0;


}
size_t SeqList::Size()const
{


  return _size;
}
size_t SeqList::Capacity()const
{
   return _capacity;
}
DataType&SeqList::operator[](size_t index)
{  
        if(index < _size)  
        {  
            return _pArr[index];  
        }  
    } 
const DataType& SeqList::operator[](size_t index)const
{
return _pArr[index];
}
DataType& SeqList::Front()
{
  assert(_size>0);
  return _pArr[0];
}
const DataType& SeqList::Front()const
{
  assert(_size>0);
  return _pArr[0];
}
DataType&SeqList::Back()
{
   assert(_size>0);
   return _pArr[_size-1];
}
const DataType& SeqList::Back()const  
{  
    assert(_size > 0);  
    return _pArr[_size-1];  
} 
int SeqList::Find(const DataType& d)
{  
    size_t i = 0;  
    for(i=0; i<_size; i++)  
    {  
        if(_pArr[i] == d)  
            return i;  
    }  
    return -1;  
}  
void SeqList::Clear()
{
   if(NULL != _pArr)
   {
     delete []_pArr;


   }
}
void Funtest()  
{  
    int arr[5] = {0};  
    SeqList s1;  
    SeqList s2(arr,5);  
    s1.PushBack(1);  
    s1.PushBack(2);  
    s1.PushBack(3);  
    s1.PushBack(4);  
    cout<<s1<<endl;  
    s1.PopBack();  
    cout<<s1<<endl;  
    s1.Insert(1,5);  
    cout<<s1<<endl;  
    s1.Erase(1);  
    cout<<s1<<endl;  
    int ret = s1.Find(2);  
    if(ret == -1)  
    cout<<"未找到元素"<<endl;  
    else  
    cout<<ret<<endl;  
    ret = s1.size();  
    cout<<ret<<endl;  
    ret = s1.Capacity();  
    cout<<ret<<endl;  
    ret = s1.Back();  
    cout<<ret<<endl;  
    ret = s1.Front();  
    cout<<ret<<endl;  
    bool r = s1.Empty();  
    cout<<r<<endl;  
    s2 = s1;  
    cout<<s2<<endl;  
}  
  
int main()  
{  
    Funtest();  
    system("pause");  
    return 0;  
}