Tableau d'objets de classe génériques C++

Question

J'ai une classe générique Queue qui contient un modèle Ttype2 comme emplacement pour le type de données qui seront stockées dans le champ d'information de chaque noeud. Dans ma classe de pilote, je veux instancier un tableau d'objets de classe Queue mais je n'arrive pas à le comprendre. Comment pourrais-je faire cela?

Ceux-ci ne fonctionne pas, mais illustrent ce que je suis en train d'accomplir:

// 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` 

déclaration Queue classe et constructeur à l'intérieur de la tête Queue.h:

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

Cela fonctionne:

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

Vous devez donner des paramètres réels à votre modèle lors de l'instanciation.

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

---

vous devez également définir votre type Node<>. Et si vous voulez attribuer NULL à Rear et Front il, d'abord envisager de faire des pointeurs, en second lieu utiliser nullptr au lieu de NULL.

Answer 2

Je vais ajouter à la solution de Yola que si je veux garder beaucoup de différents Queue<XXX> dans un seul tableau,
Je crée généralement une classe d'interface Queue_base.

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

Ici est en direct demo.
Notez que l'utilisation de la fonction virtuelle réduit un peu les performances.

Il va également perdre le type (réduire à Queue_base*) et restreindre certains appels de fonction, mais il est utile pour certains cas réels.

Pour étendre son utilisation Node<T> peut également hériter d'une nouvelle classe Node_Base qui a toutes les fonctions communes de Node<T>, par ex. : -

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

Cela dépend cependant de votre demande.