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 == 0; }

    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 < 1)
    {
        string message = "the iniCapacity must be > 0";
        throw illegalParameterValue(message);
    }
    //throw 1; 
    arrayListCapacity = iniCapacity;
    element = new T[arrayListCapacity];
    arrayListSize = 0;
}

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 < 0 || index >= arrayListSize){
        throw illegalParameterValue("the index is wrong.");
    }
    return element[index];
}

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

//按值删除，仅删除第一次出现的位置,通过equal_to实现
template <class T>
void arrayList<T>::myEraseValue(T &theElement){
    
    for (int i = 0; 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 < 0 || index > arrayListSize){
        throw illegalParameterValue("the index is wrong.");
    }

    if (arrayListSize >= arrayListCapacity){
        int tmpCapacity = arrayListCapacity * 2;
        T *tmpElement = new T[tmpCapacity];
        copy(this->element, this->element+this->arrayListSize, tmpElement);
        this->~arrayList(); 
        this->element = tmpElement;
        arrayListCapacity = arrayListCapacity * 2;
        //delete [] tmpElement;
    }
    copy_backward(this->element + index, this->element + arrayListSize, this->element + arrayListSize + 1);
    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(2);
    int a1 = 1, a2 = 2, a3 = 3;
    
    mylist.myInsert(0, a1);
    mylist.myInsert(1, a2);
    mylist.myInsert(2, a3);
    
    mylist.myErasePos(0);
    int b = 2;
    mylist.myEraseValue(b);
    mylist.output(cout);
    cout << endl;
    
    cout << mylist.myGet(1) << endl;
    mylist.output(cout);
    
    system("pause");
    return 0;
}

自定义顺序表类

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

//自定义顺序表类模板
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 == 0; }

    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 < 1)
    {
        string message = "the iniCapacity must be > 0";
        throw illegalParameterValue(message);
    }
    //throw 1; 
    arrayListCapacity = iniCapacity;
    element = new T[arrayListCapacity];
    arrayListSize = 0;
}

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 < 0 || 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 < 0 || index > arrayListSize){
        throw illegalParameterValue("the index is wrong.");
    }

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

索引删除

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

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