C++求解

参数类型怎么修改

#ifndef Array_H
#define Array_H

template<class T>
class Array { //数组类模板定义
private:
    T* list; //用于存放动态分配的数组内存首地址
    int size; //数组大小(元素个数)
public:
    Array(int sz = 50); //构造函数
    Array(const Array<T>& a); //复制构造函数
    ~Array(); //析构函数
    Array<T>& operator = (const Array<T>& rhs);
    T& operator [] (int i); //重载“[]”
    const T& operator[](int i) const; //重载“[]”常函数
    operator T* (); //重载到T*类型的转换
    operator const T* () const;
    int getSize() const; //取数组的大小
    void resize(int sz); //修改数组的大小

};
#endif // !Array_H

#include"动态数组.h"
#include<iostream>
#include<cassert>
using namespace std;

    template<class T>
    int Array<T>::getSize() const
    {
        return size; //返回数组长度
    }

    template<class T>
    void Array<T>::resize(int sz)
    {
        size = sz;
    }

    template <class T>
    Array <T>::Array(int sz) { //构造函数
        assert(sz >= 0); //sz为数组大小(元素个数)，应当非负
        size = sz; //将元素个数赋值给变量size
        list = new T[size]; //动态分配size个T类型的元素空间
    }

    template <class T>
    Array<T>::~Array() { //构造函数
        delete[] list;
    }

    template <class T>
    Array<T>::Array(const Array<T>& a) { //复制构造函数
        size = a.size; //从对象x取得数组大小,并赋值给当前对象的成员
        list = new T[size]; //动态分配n个T类型的元素空间
        for (int i = 0; i < size; i++) { //从对象a复制数组元素到本对象
            list[i] = a.list[i];
        }
    }

    //重载“=”运算符，将对象rhs赋值给本对象，实现对象之间的整体赋值
    template<class T>
    Array<T>& Array<T>::operator = (const Array<T>& rhs) {
        if (&rhs != this) {
            //如果本对象中数组大小与rhs不同，则删除数组原有内存，然后重新分配
            if (size != rhs.size) {
                delete[]list; //删除数组原有内存
                size = rhs.size; //设置本对象的数组大小
                list = new T[size]; //重新分配size个元素的内存
            }
            //从对象X复制数组元素到本对象
            for (int i = 0; i < size; i++) {
                list[i] = rhs.list[i];
            }
        }
        return *this; //返回当前对象的引用
    }

    //重载下标运算符，实现与普通数组一样通过下标访问元素,具有越界检查功能
    template <class T>
    T& Array<T>::operator[](int n) {
        //assert 断言 相等于 异常判断
        assert(n >= 0 && n < size);// 检查下标是否越界
        return list[n]; //返回下标为n的数组元素
    }

    template<class T>
    inline const T& Array<T>::operator[](int i) const
    {
        // TODO: 在此处插入 return 语句
    }

    template<class T>
    inline Array<T>::operator T* ()
    {
        return list;//返回当前对象中私有数组的首地址
    }

    template<class T>
    inline Array<T>::operator const T* () const
    {
        
    }
    

//指针转换运算符的作用
void read(int* p, int n) {
    for (int i = 0; i < n; i++) {
        cin >> p[i];
    }
}

int main() {
    //int a[10];  
     Array<int> a[10];
    read(a, 10);
    return 0;
}