Array generischer Klassenobjekte C++

Question

Ich habe eine generische Klasse Queue, die eine Vorlage Ttype2 als Platzhalter für den Datentyp enthält, der im Informationsfeld jedes Knotens gespeichert wird. In meiner Treiberklasse möchte ich ein Array von Queue Klassenobjekten instanziieren, aber ich kann es nicht herausfinden. Wie kann ich das machen?

// Queue Complex[] = new Queue();//invalid use of template name without identifier list 
//Queue<Ttype2> Complex[]; //template arg 1 is invalid 
// vector<Queue> Complex2[];//invalid template arguments` 

Queue Klassendeklaration und Konstruktor innerhalb Queue.h Header: zu erreichen

Dies funktionierte nicht aber zeigen, was ich versuche

template <typename Ttype2> 
class Queue 
{ 
    // Global Data Items 
    protected: 
    Node <Ttype2> Front, Rear; 
    int Length; 

    // member function prototypes 
    public: 
    Queue(); 
    void AddRear(Node <Ttype2> ThisNode); 
    Node <Ttype2> RemoveFront(); 
    void Modify(int Position, Node <Ttype2> ThisNode); 
    void ClearAll(); 
    int GetSize();` 
    Node <Ttype2> GetNode(int Position); 
    Node <Ttype2>* toArray(); 
};` 

// Constructor 
template <typename Ttype2> 
Queue <Ttype2> :: Queue() 
{ 
    Rear = Front = NULL; 
    Length = 0; 
} // End of Constructor 
` 

Answer 1

Dies funktioniert:

Queue<int> *Complex = new Queue<int>(); 
Queue<int> Complex[1]; 
vector<Queue<int>> Complex2[1]; 

Sie müssen Ihrer Vorlage echte Parameter geben, wenn Sie sie instanziieren.

Queue<Ttype2> // Ttype2 isn't a real type, use int, char, ... 

---

Auch müssen Sie Ihre Art Node<> definieren. Und wenn Sie NULL zu Rear und Front es zuweisen möchten, überlegen Sie zuerst, sie Zeiger zu machen, zweite Verwendung nullptr anstelle von NULL.

Answer 2

ich Yola-Lösung hinzufügen wird, wenn ich viele verschiedene Queue<XXX> in einem einzigen Array behalten möchten,
ich in der Regel eine Schnittstelle Klasse Queue_base erstellen.

class Queue_base{ 
    public: virtual void func()=0; 
}; 

template <typename Ttype2>class Queue : public Queue_base{ 
    public: void func(){ 
     //... some code 
    } 
}; 

int main() { 
    Queue_base* complex[2]; 
    complex[0]=new Queue<int>(); 
    complex[1]=new Queue<float>(); 
    complex[0]->func(); 
    std::vector<Queue_base*> complex2; 
    complex2.push_back(new Queue<char>()); 
    Queue<int>* c1=static_cast<Queue<int>*>(complex[0]); 
    return 0; 
} 

Hier ist Live demo.
Beachten Sie, dass die Verwendung virtueller Funktionen die Leistung ein wenig reduziert.

Es wird auch den Typ verlieren (reduzieren auf Queue_base*) und einige Funktionsaufruf einschränken, aber es ist nützlich für einige reale Fälle.

Um seine Verwendung zu erweitern, kann Node<T> auch von einer neuen Klasse Node_Base erben, die alle gemeinsamen Funktionen von Node<T>, z. : -

template <typename Ttype2> class Queue : public Queue_Base{ 
    // Global Data Items 
    protected: 
    Node_Base* Front; //Front = new Node<Ttype2>(); 
    Node_Base* Rear;  

Es hängt jedoch von Ihrer Nachfrage ab.