C++ 模板T类数组 大小） 大小=此->大小； 对于（int i=0；i

以下是作业： 创建一个包含两个私有数据成员的类模板：T*array和int size。该类使用构造函数根据输入的大小分配数组。有一个成员函数，允许用户根据大小填充数组。此外，还有一个成员函数对数组进行排序并显示排序后的元素。使用析构函数删除数组。开发main（）以创建两个对象来调用成员函数。因此，第一个对象将保存其double类型的数组，而另一个对象将保存其int类型的数组

以下是我的想法，但出现了一个错误“分配不完整的'T'类型”：

#包括
#包括
#包括
使用名称空间std；
模板
类DynArray{
受保护的：
整数大小；
T**dynamiccarray=新的T[尺寸]；
公众：
DynArray（）{
void CreateArray（）{
大小；
对于（int i=0；i对于（int i=0；i从您提供的描述来看，您希望这样做：

#include <iostream>
#include <algorithm>

using namespace std;
    
template <class T>
class DynArray {
    
    protected:
        int size;
        T * DynamicArray;

    public:
        DynArray(size_t s): size(s) {
            DynamicArray = new T[s];
        }

        void CreateArray(){
            size_t size;
            cout << "Enter size of Array: ";
            cin >> size;
            if(size > this->size)
              size = this->size;
            for (int i = 0; i<size; i++) {
                cout << "Element " << i << ": ";
                cin >> DynamicArray[i];
            }
        }
        //Sort Array
        void Sort()
        {
           std::sort(DynamicArray, DynamicArray+size);                                                                                                                                            
        }

        DynArray() {
            delete []DynamicArray;
        }
};

int main() {
    DynArray<double> dob(3);
    DynArray<int> di(3);
    dob.CreateArray();
    di.CreateArray();
    dob.Sort(); di.Sort();
}


                                                                                                                                                                   

#包括
#包括
使用名称空间std；
模板
类DynArray{
受保护的：
整数大小；
T*卡雷；
公众：
DynArray（尺寸）：尺寸{
DynamicArray=新的T[s]；
}
void CreateArray（）{
大小；
大小；
如果（大小>此->大小）
大小=此->大小；
对于（int i=0；i我想知道您是创建一维数组还是二维数组，您最初的要求是一维数组，但您在代码中使用的是二维数组。无论如何，我还是使用一维数组

错误：分配不完整的类型“T”

T *DynamicArray = new T[size];

您在这里尝试的是类内初始化，它可以为静态数据成员进行初始化，并且是非静态数据成员的c++11扩展。因此，我建议您不要这样做，因为您正在学习。您只能声明成员，不能在这里进行初始化

即使将其设置为静态，也无法分配，因为模板类型
T
只有在对象创建之后才知道，因此编译器不知道它将在编译期间分配的类型。
因此，它应该是简单的

T *DynamicArray;

嵌套函数

 C++不支持嵌套函数，学习C++语法。
构造函数和析构函数的使用
构造函数将执行
CreateArray（）
的功能，析构函数将执行
DeleteArray（）

实例化模板类

您应该明确提到模板类将要使用的尖括号中的类型

DynArray<int> intArray; // if you want to use int
DynArray<float> floatArray;

如果您纠正了所有这些问题，那么您的最终骨架将如下所示

template <class T>
class DynArray {
protected:
    int size;
    T *DynamicArray ;

public:
    DynArray() {
        // initailize DynamicArray here
        // use your CreateArray() code here
    }

    void sort() {
        // your own sort logic
        // No need to pass the size to this function, its a member function 
    }

    ~DynArray() {
        // use your DeleteArray() code here
    }
};

int main() {
    DynArray<int> intArray;
    intArray.sort()
    return 0;
}

模板
类DynArray{
受保护的：
整数大小；
T*卡雷；
公众：
DynArray（）{
//在这里初始化DynamicArray
//在此处使用CreateArray（）代码
}
空排序（）{
//你自己的排序逻辑
//无需将大小传递给此函数，它是一个成员函数
}
~DynArray（）{
//在此处使用DeleteArray（）代码
}
};
int main（）{
DynArray-intArray；
intArray.sort（）
返回0；
}

很简单，不是吗？：）

DynArray<int> intArray; // if you want to use int
DynArray<float> floatArray;

DynArray<MyCustomClass> customArray;

template <class T>
class DynArray {
protected:
    int size;
    T *DynamicArray ;

public:
    DynArray() {
        // initailize DynamicArray here
        // use your CreateArray() code here
    }

    void sort() {
        // your own sort logic
        // No need to pass the size to this function, its a member function 
    }

    ~DynArray() {
        // use your DeleteArray() code here
    }
};

int main() {
    DynArray<int> intArray;
    intArray.sort()
    return 0;
}