C++利用动态数组实现顺序表（不限数据类型）

　　通过类模板实现顺序表时，若进行比较和遍历操作，模板元素可以通过STL中的equal_to仿函数实现，或者通过回调函数实现。若进行复制操作，可以采用STL的算法函数，也可以通过操作地址实现。关于回调函数和地址操作可以查看：C语言利用动态数组实现顺序表（不限数据类型）

　　主要功能：初始化，按照索引插入，删除，遍历，按索引返回元素，返回顺序表的容量，元素个数，及扩容操作。

 #include <iostream>
 #include <vector>
 #include <string>

 using namespace std;

 //异常类
 class illegalParameterValue{
 public:
     illegalParameterValue();
     illegalParameterValue(string myMessage);
     void outPutMessage();
 private:
     string message;
 };

 illegalParameterValue::illegalParameterValue(){
     this->message = "illegal Parameter Value";
 }

 illegalParameterValue::illegalParameterValue(string myMessage){
     this->message = myMessage;
 }

 void illegalParameterValue::outPutMessage(){
     cout << this->message << endl;
 }

 //自定义顺序表类模板
 template<class T>
 class arrayList{
 public:
     //构造函数
     arrayList();
     arrayList(int iniCapacity);
     //复制构造函数
     arrayList(const arrayList<T>& theList);

     ~arrayList(){ delete[] element; }

     //ADT方法
     int mySize() const { return this->arrayListSize; }
     int myCapacity() const { return this->arrayListCapacity; }
     bool myEmpty() const { return arrayListSize == ; }

     void myForeach() const;
     T& myGet(int index) const;
     void myErasePos(int index);
     void myEraseValue(T& theElement);
     void myInsert(int index, T& theElement);
     void output(ostream& out)const;
 private:
     int arrayListCapacity;
     int arrayListSize;
     T* element;
 };

 //构造函数，抛出异常时需要注意释放已创建的动态数据
 //如果抛出异常后，没有处理，会继续向上抛出，直到main函数处理
 //这里只是抛出，并没有捕获，因此不会显示message
 template <class T>
 arrayList<T>::arrayList(){}

 template <class T>
 arrayList<T>::arrayList(int iniCapacity){
     if (iniCapacity < )
     {
         string message = "the iniCapacity must be > 0";
         throw illegalParameterValue(message);
     }
     //throw 1;
     arrayListCapacity = iniCapacity;
     element = new T[arrayListCapacity];
     arrayListSize = ;
 }

 template <class T>
 arrayList<T>::arrayList(const arrayList<T>& theList){
     arrayListCapacity = theList.arrayListCapacity;
     arrayListSize = theList.arrayListSize;
     element = new T[arrayListCapacity];
     copy(theList.element, theList.element + arrayListSize, element);
 }

 //ADT方法
 //根据pos获取元素
 template<class T>
 T &arrayList<T>::myGet(int index)const{
     if (index <  || index >= arrayListSize){
         throw illegalParameterValue("the index is wrong.");
     }
     return element[index];
 }

 //按位置删除元素
 template <class T>
 void arrayList<T>::myErasePos(int index){
     if (index <  || index >= arrayListSize){
         throw illegalParameterValue("the index is wrong.");
     }
     //整体移动
     copy(element + index + , element + arrayListSize, element+ index );
     arrayListSize--;
 }

 //按值删除，仅删除第一次出现的位置,通过equal_to实现
 template <class T>
 void arrayList<T>::myEraseValue(T &theElement){

     for (int i = ; i != arrayListSize; i++){
         if (equal_to<T>()(element[i], theElement)){

             cout << "mid" << endl;
             myErasePos(i);
             break;
         }
     }
 }

 //按位置插入元素，并扩容
 //这里有个非常隐蔽的错误,tmpElement通过new开辟内存空间
 //按道理需要释放tmpElement，但tmpElement的地址赋给element，两个变量指向同一个内存地址
 //element本身运行或下次进入条件就会析构掉，释放掉该块内存
 //如果提前释放掉tmpElement,则提前释放了该块内存，则会二次释放造成内存泄漏
 template <class T>
 void arrayList<T>::myInsert(int index, T &theElement){
     if (index <  || index > arrayListSize){
         throw illegalParameterValue("the index is wrong.");
     }

     if (arrayListSize >= arrayListCapacity){
         int tmpCapacity = arrayListCapacity * ;
         T *tmpElement = new T[tmpCapacity];
         copy(this->element, this->element+this->arrayListSize, tmpElement);
         this->~arrayList();
         this->element = tmpElement;
         arrayListCapacity = arrayListCapacity * ;
         //delete [] tmpElement;
     }
     copy_backward(this->element + index, this->element + arrayListSize, this->element + arrayListSize + );
     this->element[index] = theElement;
     arrayListSize++;
 }

 //输出函数
 template <class T>
 void arrayList<T>::output(ostream& out)const{
     copy(element, element + arrayListSize, ostream_iterator<T>(out, " "));
 }
 //重载<<
 template <class T>
 ostream& operator<<(ostream& out, const arrayList<T>& x){
     x.output(out);
     return out;
 }

 int main(){
     arrayList<int>mylist();
     int a1 = , a2 = , a3 = ;

     mylist.myInsert(, a1);
     mylist.myInsert(, a2);
     mylist.myInsert(, a3);

     mylist.myErasePos();
     int b = ;
     mylist.myEraseValue(b);
     mylist.output(cout);
     cout << endl;

     cout << mylist.myGet() << endl;
     mylist.output(cout);

     system("pause");
     return ;
 }

完整代码

自定义顺序表类

　　通过类模板自定义顺序表类，并在类内实现了返回顺序表的容量和元素个数等操作。

 //自定义顺序表类模板
 template<class T>
 class arrayList{
 public:
     //构造函数
     arrayList();
     arrayList(int iniCapacity);
     //复制构造函数
     arrayList(const arrayList<T>& theList);

     ~arrayList(){ delete[] element; }

     //ADT方法
     int mySize() const { return this->arrayListSize; }
     int myCapacity() const { return this->arrayListCapacity; }
     bool myEmpty() const { return arrayListSize == ; }

     void myForeach() const;
     T& myGet(int index) const;
     void myErasePos(int index);
     void myEraseValue(T& theElement);
     void myInsert(int index, T& theElement);
     void output(ostream& out)const;
 private:
     int arrayListCapacity;
     int arrayListSize;
     T* element;
 };

初始化

　　利用C++类模板实现顺序表，最重要的是构造函数及复制构造函数。顺序表中的元素移动，通过STL的内置copy算法实现。另外，类外实现成员函数时，函数需要加作用域，成员属性可以直接使用，如element等。

 //构造函数，抛出异常时需要注意释放已创建的动态数据
 //如果抛出异常后，没有处理，会继续向上抛出，直到main函数处理
 //这里只是抛出，并没有捕获，因此不会显示message
 template <class T>
 arrayList<T>::arrayList(){}

 template <class T>
 arrayList<T>::arrayList(int iniCapacity){
     if (iniCapacity < )
     {
         string message = "the iniCapacity must be > 0";
         throw illegalParameterValue(message);
     }
     //throw 1;
     arrayListCapacity = iniCapacity;
     element = new T[arrayListCapacity];
     arrayListSize = ;
 }

 template <class T>
 arrayList<T>::arrayList(const arrayList<T>& theList){
     arrayListCapacity = theList.arrayListCapacity;
     arrayListSize = theList.arrayListSize;
     element = new T[arrayListCapacity];
     copy(theList.element, theList.element + arrayListSize, element);
 }

索引元素

 //根据pos获取元素
 template<class T>
 T &arrayList<T>::myGet(int index)const{
     if (index <  || index >= arrayListSize){
         throw illegalParameterValue("the index is wrong.");
     }
     return element[index];
 }

索引插入

　　索引插入时，需要对边界条件进行判断，由STL内置copy_backward算法实现顺序表元素的移动，因为需要将最右侧的元素先移动；copy算法是将最左侧的元素先移动。

　　如果顺序表容量过小时，则需要对顺序表进行扩容，扩容需要注意两点：（1）需要将element指向新的空间；（2）利用临时变量动态扩容时，需要注意释放时机和释放对象。

 //按位置插入元素，并扩容
 //这里有个非常隐蔽的错误,tmpElement通过new开辟内存空间
 //按道理需要释放tmpElement，但tmpElement的地址赋给element，两个变量指向同一个内存地址
 //element本身运行或下次进入条件就会析构掉，释放掉该块内存
 //如果提前释放掉tmpElement,则提前释放了该块内存，则会二次释放造成内存泄漏
 template <class T>
 void arrayList<T>::myInsert(int index, T &theElement){
     if (index <  || index > arrayListSize){
         throw illegalParameterValue("the index is wrong.");
     }

     if (arrayListSize >= arrayListCapacity){
         int tmpCapacity = arrayListCapacity * ;
         T *tmpElement = new T[tmpCapacity];
         copy(this->element, this->element+this->arrayListSize, tmpElement);
         this->~arrayList();
         this->element = tmpElement;
         arrayListCapacity = arrayListCapacity * ;
         //delete [] tmpElement;
     }
     copy_backward(this->element + index, this->element + arrayListSize, this->element + arrayListSize + );
     this->element[index] = theElement;
     arrayListSize++;
 }

索引删除

　　 判断边界条件时需要注意，动态数组的索引与位置相差1，因此当index == arrayListsize时，也会报错。另外，需要注意删除后，元素个数减一。

 //按位置删除元素
 template <class T>
 void arrayList<T>::myErasePos(int index){
     if (index <  || index >= arrayListSize){
         throw illegalParameterValue("the index is wrong.");
     }
     //整体移动
     copy(element + index + , element + arrayListSize, element+ index );
     arrayListSize--;
 }

按值删除

　　 按值删除，这里仅实现了删除元素第一次出现的位置，顺序表中元素间的比较通过STL关系运算符仿函数实现。另外，该函数不具有普适性，对int， float等大部分内置类型可以适用，对于结构体等数据类型，需要对函数进行重载，改变函数参数。如，age和name的class，仿函数不能直接对对象进行比较，只能是对某一个成员属性进行比较。C语言中是用回调函数，让用户自定义操作。

 //按值删除，仅删除第一次出现的位置,通过equal_to实现
 template <class T>
 void arrayList<T>::myEraseValue(T &theElement){

     for (int i = ; i != arrayListSize; i++){
         if (equal_to<T>()(element[i], theElement)){

             cout << "mid" << endl;
             myErasePos(i);
             break;
         }
     }
 }

遍历

　　对于类模板实现遍历操作， 需要用到STL中的输出流迭代器，另外需要对<<进行重载。C语言中是用回调函数进行操作的，需要用户根据数据类型自定义输出函数。

 //输出函数
 template <class T>
 void arrayList<T>::output(ostream& out)const{
     copy(element, element + arrayListSize, ostream_iterator<T>(out, " "));
 }
 //重载<<
 template <class T>
 ostream& operator<<(ostream& out, const arrayList<T>& x){
     x.output(out);
     return out;
 }