Template-Klasse T-Array

Ich habe ein (was einfach sein sollte) Zuordnung in meine C++ - Klasse.

Hier ist die Aufgabe:
Erstellen Sie eine Vorlage-Klasse enthält zwei private Daten Mitglieder: T * int-array und Größe. Verwendet die Klasse einen Konstruktor zuweisen, das array basierend auf der Größe eingetragen. Es ist member-Funktion, die ermöglicht dem Benutzer, füllen Sie das array basierend auf der Größe. Darüber hinaus gibt es eine member-Funktion sortiert das array und zeigt die sortierten Elemente. Verwenden Sie den Destruktor zu löschen, das array. Entwickeln Sie die Funktion main( ) zwei Objekte zu nennen member-Funktionen. Als ein Ergebnis, das erste Objekt, halten Sie seine array von Typ double, und die anderen halten Ihre array von Typ int.

Hier ist was ich kam mit, sondern kommt mit einer Fehlermeldung "Zuordnung der unvollständigen Typ 'T'":

#include <iostream>
#include <new>
#include <vector>
using namespace std;
template <class T>
class DynArray {
protected:

int size;
T ** DynamicArray = new T[size];

public:
DynArray(){
void CreateArray(){
cout << "Enter size of Array: ";
cin >> size;
for (int i = 0; i < size; ++i){
DynamicArray[i] = new T();
}
for (int i = 0; i<size; i++) {
cout << "Element " << i << ": ";
cin >> DynamicArray[i];}
}
//Sort Array
void Sort(T a[], int size)
{
int idx, pass;
for (pass=0; pass<size; ++pass){
for (idx=0; idx<size-1; ++idx){
if (a[idx] > a[idx+1])
swap(a[idx], a[idx+1]);}
}
for (int i=0; i<size; ++i) {
for (idx = 0; idx<size-1; ++idx) {
cout << a[idx] << " ";
}
}
}
void DeleteArray(){
for (int i = 0; i < size; ++i){
delete DynamicArray[i];
}
delete[] DynamicArray;
}
};
int main() {
DynArray<class T>();
return 0;
}

Nicht sicher, ob ich bin ein völliger retard in meine Linie des Denkens, oder, wenn ich bin fehlt nur noch ein kleines element. Jede Hilfe ist toll.

Danke @jblixr und @user3655463 für Ihre Hilfe. Ich habe es geklappt, ich denke, nach euren Tipps und Hilfe.
Hier ist, was ich kam mit der Referenz, wenn jemand arbeitet.

#include <iostream>
#include <new>
#include <algorithm>
using namespace std;

//Template Class T
template <class T>
class DynArray {
protected:
    int size;
    T * DynamicArray;
public:
    DynArray(){};
    DynArray(size_t s): size(s) {
        DynamicArray = new T[size];
        for (int i = 0; i<size; i++) {
            cout << "Element " << i << ": ";
            cin >> DynamicArray[i];

        }
    }
    //Sort Array
    void Sort(){
        sort(DynamicArray, DynamicArray+size);
        for (int i=0; i<size; i++) {
            cout << DynamicArray[i] << endl;
        }
    }

    //Clear Heap
    ~DynArray() {
        delete []DynamicArray;
    }
};

int main() {
    int sizeOfArry;
    cout << "Enter size of Array: ";
    cin >> sizeOfArry;

    //Use as an int Array;
    DynArray<int> intArray = DynArray<int>(sizeOfArry);
    intArray.Sort();
}

InformationsquelleAutor B. N. | 2016-11-18

  1. 0

    Frage ich mich, ob Sie sind, creating a one-dimensional array oder ein 2D-array, Ihr Einstieg in die Staaten ein-dimensionales array, sondern Sie sind mit 2D-array im code. Wie auch immer, ich Spiele zusammen mit einem eindimensionalen array.

    error: allocation of incomplete type 'T'

    T *DynamicArray = new T[size];

    Was Sie versuchen zu tun, hier ist in-Klasse initialisiert, die getan werden kann, für statische Daten-member und es ist eine c++11-Erweiterung für nicht-statischen Daten-member. Also ich schlage vor, Sie nicht zu tun, da Sie gelernt haben. Sie können nur erklären, das die Mitglieder und nicht initialisieren hier.

    Selbst wenn Sie statisch ist es nicht zugeordnet werden kann, weil die template-Typ T ist nur bekannt, nachdem-Objekt erstellen, Damit der compiler ist nicht bewusst, dass der Typ es geht um zuordnen, während der compile-Zeit.
    So sollte es einfach als

    T *DynamicArray;

    Verschachtelte Funktionen

    C++ nicht unterstützt verschachtelte Funktionen, lernen C++ - syntax.

    - Nutzung von Konstruktoren und Destruktoren

    Konstruktor wird die Funktionalität von CreateArray() und der Destruktor wird die functionlaity von DeleteArray()

    Instanziierung einer Vorlage-Klasse

    Sollten Sie explizit erwähnen die Art in den Spitzen Klammern, die die template-Klasse verwenden wird,

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

    Können Sie auch Ihre eigenen benutzerdefinierten Klasse Typ T hoffen, dass Sie lernen, schnell in Ihre Klasse.

    DynArray<MyCustomClass> customArray;

    Wenn Sie korrekt alle diese Dinge, die dann Ihre endgültige Skelett wird sein, wie die unten eine 

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

    Einfach, ist es nicht? 🙂

    InformationsquelleAutor jblixr

  2. 0

    Aus der Beschreibung, die Sie gestellt haben, scheint mir, Sie wollen zu do sth wie:

      #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();
    }

    InformationsquelleAutor Mateusz Wojtczak

Schreibe einen Kommentar