template<class T, int SIZE = 20>

这是一个模板类的定义，其中T是一个类型参数，SIZE是一个非类型参数，它的默认值是20。这个模板类可以用来定义一个大小固定为SIZE的数组，数组元素类型为T。在使用时，可以根据需要指定T的具体类型和数组的大小，例如：template<class T, int SIZE = 20> class MyArray; MyArray<int, 10> arr; 表示定义了一个大小为10的int类型数组。

相关问题

1、理解下面的动态数组类模板，它由一系列位置连续、任意数量相同类型的元素组成，其元素个数可在程序运行时改变，并完成该类中没有完成的成员函数（不允许改变已有代码），并设计主函数，实现对该模板类的功能测试。 #include <iostream> using namespace std; #include <stdlib.h> //容错处理 enum ErrorType { invalidArraySize, memoryAllocatetionError, indexOutOfRang }; char *errorMsg[] = { "Invalid array size", "Memory allocation error", "Invalid index" }; template <class T> class Array { private: T* alist; int size; void Error(ErrorType error) const;//输出错误信息 public: Array(int sz=50);//构造函数 Array(const Array<T>& X);//拷贝构造函数 ~Array(void);//析构函数 Array<T>& operator=(const Array<T>& rhs);//重载赋值运算符 T& operator[](int i);//重载下标运算符 int GetSize(void) const;//获取数组大小 void Resize(int sz);//重新设置数组大小 }; template <class T> Array<T>::Array(int sz) { if(sz <= 0) Error(invalidArraySize); size = sz; alist = new T[size]; if(alist == 0) Error(memoryAllocatetionError); } template <class T> Array<T>::Array(const Array<T>& X) { int n = X.size; size = n; alist = new T[n]; if(alist == 0) Error(memoryAllocatetionError); T* srcptr = X.alist; T* destptr = alist; while(n--) *destptr++ = *srcptr++; } template<class T> Array<T>::~Array() { delete[] alist; } template <class T> Array<T>& Array<T>::operator=(const Array<T> &rhs) { int n = rhs.size; if(size != n) { delete[] alist; alist = new T[n]; if(alist == 0) Error(memoryAllocatetionError); size = n; } T* destptr = alist; T* srcptr = rhs.alist; while(n--) *destptr++ = *srcptr++; return *this; } template<class T> T& Array<T>::operator[](int n) { if(n < 0 || n > size-1) Error(indexOutOfRang); return alist[n]; }

以下是对 Array 类的成员函数的完成，并设计了主函数进行测试：

template<class T>
void Array<T>::Error(ErrorType error) const {
    cout << "Error: " << errorMsg[error] << endl;
    exit(1);
}

template<class T>
int Array<T>::GetSize() const {
    return size;
}

template<class T>
void Array<T>::Resize(int sz) {
    if (sz <= 0) {
        Error(invalidArraySize);
    }
    T* newAlist = new T[sz];
    if (newAlist == 0) {
        Error(memoryAllocatetionError);
    }
    int n = (sz < size ? sz : size);
    for (int i = 0; i < n; i++) {
        newAlist[i] = alist[i];
    }
    delete[] alist;
    alist = newAlist;
    size = sz;
}

int main() {
    Array<int> arr(5);
    arr[0] = 1;
    arr[1] = 2;
    arr[2] = 3;
    arr[3] = 4;
    arr[4] = 5;
    cout << "Array size: " << arr.GetSize() << endl;
    for (int i = 0; i < arr.GetSize(); i++) {
        cout << "arr[" << i << "] = " << arr[i] << endl;
    }

    arr.Resize(7);
    arr[5] = 6;
    arr[6] = 7;
    cout << "Array size: " << arr.GetSize() << endl;
    for (int i = 0; i < arr.GetSize(); i++) {
        cout << "arr[" << i << "] = " << arr[i] << endl;
    }

    Array<string> strArr(3);
    strArr[0] = "Hello";
    strArr[1] = "World";
    strArr[2] = "!";
    cout << "Array size: " << strArr.GetSize() << endl;
    for (int i = 0; i < strArr.GetSize(); i++) {
        cout << "strArr[" << i << "] = " << strArr[i] << endl;
    }

    return 0;
}

该程序首先创建了一个大小为 5 的 `Array<int>` 对象，并对其进行了初始化。然后，调用 `GetSize()` 函数获取数组大小，并使用重载的下标运算符 `[]` 访问每个元素。接着，调用 `Resize()` 函数将数组大小更改为 7，并在新的两个位置上存储新的整数值。最后，创建了一个大小为 3 的 `Array<string>` 对象，并用字符串初始化它。同样，调用 `GetSize()` 函数并使用重载的下标运算符 `[]` 访问每个元素。

template<class T,int OTER_SIZE> friend class Stack<T, OTER_SIZE>;友元模板声明无效

如果在类中声明了友元模板类，那么它的模板参数列表需要与被声明类的模板参数列表完全一致，并且需要在类外部再次声明一遍。例如，如果我们在`Stack`类中声明了一个友元模板类`OtherStack`，那么我们需要这样写：

template<class T, int OTHER_SIZE>
class OtherStack;

template<class T, int SIZE>
class Stack {
public:
    // ...
private:
    // ...
    template<class T, int OTHER_SIZE>
    friend class OtherStack;
};

注意，这里的`OtherStack`类模板声明需要在类外部进行，而且模板参数列表需要与类内部声明的完全一致。