动态数组（C++）

#include<iostream>
#include <sstream>
#include<iterator>
#include<algorithm>

using namespace std;

// 重写copy代码
template<class iterator>
void copy(iterator start, iterator end, iterator to) {
    // 从start复制到[to, to+end-start)
    while (start != end)
        *(to++) = *(start++);
}

template<class T>
class linearList {
public:
    virtual ~linearList() = default;;

    virtual bool empty() const = 0; /* 返回true，当且仅当线性表为空 */
    virtual int size() const = 0; /* 返回线性表的元素个数 */
    virtual T &get(int theIndex) const = 0; /* 返回索引为theIndex的元素 */
    virtual int indexOf(const T &theElement) const = 0; /* 返回元素theElement第一次出现时的索引 */
    virtual void erase(int theIndex) = 0; /* 删除索引为theIndex的元素 */
    virtual void insert(int theIndex, const T &theElement) = 0;/* 把theElement插入线性表中索引为theIndex的位置上 */
    virtual void output(ostream &out) const = 0;/*把线性表插入输出流*/
};

class illegalParameterValue {
public:
    illegalParameterValue() : message("Illegal parameter value") {}

    explicit illegalParameterValue(char *theMessage) {
        message = theMessage;
    }

    explicit illegalParameterValue(const string &theMessage) {
        message = theMessage;
        cout << message << endl;
    }

    void outputMessage() { cout << message << endl; }

private:
    string message;
};

/* 改变一个一位数组的长度*/
template<class T>
void changeLength1D(T *&a, int oldLength, int newLength) {
    if (newLength < 0)  /* 如果新表长小于0 */
        throw illegalParameterValue("new length muse be >= 0"); /* 抛出异常*/
    T *temp = new T[newLength]; /* 申请新的数组空间*/
    int number = min(oldLength, newLength); /*过的原来数组长度和现在数组长度中较小者*/
    copy(a, a + number, temp); /* 将原数组中的数据放到新的数组中*/
    delete[] a; /* 删除原来数组的空间*/
    a = temp; /*将新数组空间的地址给原来的数组名*/
}

/* 类arrayList定义
 * 定义抽象类linearList的派生类arrayList
 * 来实现抽象数据类型linearList
*/
template<class T>
class arrayList : public linearList<T> {
public:
    /* 构造函数，复制构造函数和构析函数 */
    arrayList(int initialCapacity = 10);

    arrayList(const arrayList<T> &);

    ~arrayList() { delete[]element; }

    /* ADT方法 */
    bool empty() const { return listSize == 0; }

    int size() const { return listSize; }

    T &get(int theIndex) const;

    int indexOf(const T &theElement) const;

    void erase(int theIndex);

    void insert(int theIndex, const T &theElement);

    void output(ostream &out) const;

    int capacity() const { return arrayLength; }

protected:
    void checkIndex(int theIndex) const;

    T *element; /* 存储线性表元素的一维数组 */
    int arrayLength; /* 一维数组的容量 */
    int listSize; /* 线性表的元素个数 */
};

template<class T>
void arrayList<T>::checkIndex(int theIndex) const {
    if (theIndex < 0 || theIndex >= listSize) {
        ostringstream s;
        s << "index = " << theIndex << " size = " << listSize;
        throw illegalParameterValue(s.str());
    }
}

template<class T>
T &arrayList<T>::get(int theIndex) const {
    // 返回索引为theIndex的元素
    // 若此元素不存在，则抛出异常
    checkIndex(theIndex);
    return element[theIndex];
}

template<class T>
int arrayList<T>::indexOf(const T &theElement) const {
    // 返回元素theElement第一次出现时的索引
    // 若该元素不存在，则返回-1
    // 查找元素theElement
    int theIndex = (int) (find(element, element + listSize, theElement) - element);
    // 确定theElement是否找到
    if (theIndex == listSize)
        // 没有找到
        return -1;
    else
        return theIndex;
}

template<class T>
void arrayList<T>::erase(int theIndex) {
    // 删除其索引为theIndex的元素
    // 如果该元素不存在，则抛出illegal
    checkIndex(theIndex);
    // 有效索引，移动其索引大于theIndex的元素
    copy(element + theIndex + 1, element + listSize, element + theIndex);
    element[--listSize].~T(); // 调用构析函数
}

// arrayList的构造函数
template<class T>
arrayList<T>::arrayList(int initialCapacity) {
    // 构造函数
    if (initialCapacity < 1) {
        ostringstream s;
        s << "Initial capacity = " << initialCapacity << " Must be > 0";
        throw illegalParameterValue(s.str());
    }
    arrayLength = initialCapacity;
    element = new T[arrayLength];
    listSize = 0;
}

template<class T>
arrayList<T>::arrayList(const arrayList<T> &theList) {
    // 复制构造函数
    arrayLength = theList.arrayLength;
    listSize = theList.listSize;
    element = new T[arrayLength];
    copy(theList.element, theList.element + listSize, element);
}

template<class T>
void arrayList<T>::insert(int theIndex, const T &theElement) {
    // 在索引theIndex处插入元素theElement
    if (theIndex < 0 || theIndex > listSize) {
        // 无效索引
        ostringstream s;
        s << "index = " << theIndex << " size = " << listSize;
        throw illegalParameterValue(s.str());
    }
    // 有效索引，确认数组是否已满
    if (listSize == arrayLength) {
        // 数组空间已满，数组长度倍增
        changeLength1D(element, arrayLength, arrayLength * 2);
        arrayLength *= 2;
    }
    // 把元素向右移动一个位置
    copy_backward(element + theIndex, element + listSize, element + listSize + 1);
    element[theIndex] = theElement;
    ++listSize;
}

// 把一个线性表插入输出流
template<class T>
void arrayList<T>::output(ostream &out) const {
    copy(element, element + listSize, ostream_iterator<T>(cout, " "));
}

// 重载<<
template<class T>
ostream &operator<<(ostream &out, const arrayList<T> &x) {
    x.output(out);
    return out;
}

int main() {
    auto *array1 = new arrayList<int>(100);
    arrayList<double> y(100);
    cout << *array1 << endl;
    cout << y << endl;
    return 0;

}