Utilisation d'un std::queue<void*>

Bonjour, je suis un gros boulet, je ne sais pas utiliser un conteneur de la STL pour des structures de données différentes.
Je souhaite pouvoir ajouter dans la file des int, string, char*, long, unsigned char*, ... bref un peu tout ce qui est types de base, mais aussi des tableaux de string aussi.
En faisant le push d'un const char* la compilation m'a engueulé, et tout bonnement j'ai casté en void*. Est ce une bonne méthode et le contenu sera t'il correctement utilisable par la suite ?!

On m'a aussi dit de faire ma classe pour gérer les erreurs, mais la classe Queue est déjà faite je ne vois pas en quoi ce serait utile...

bref une question de première année j'ai honte

merci !

Hum si c'est des types de bases à la rigueur tu fais un queue d'union. Sinon une solution plus C++ serait de stocker des boost::variant. (si tu as un nombres fixés de type à stocker sinon boost::any).

Enfin, en général ça relève plus d'une erreur de conception d'avoir ce genre de besoin...

Je refactorise sans pouvoir changer le code incriminé
Le code envoi une succession de données par ex int, string, int, int, float, char* en passant par des méthodes dédiées. J'aimerai récupérer tout ça petit à petit dans une file à traiter à la fin pour voir ce qui a été donné.
Je pensais passer sinon par une classe abstraite AbstractParameter mis dans la file et avec chaque type différent stocké dans des classes héritant de cette classe abstraite...Je vais voir ce que ça donne, ça paraît sympa mais je suis sûr que ça va clocher quelque part!

Merci pour les explications sinon : j'ai juste pas suivi le truc de l'union (ça existe en C++ encore? ou alors ça correspond à ma classe abstraite)
et Boost je crois que je ne peux pas l'installer mais je vais peut être me lancer là dedans pour apprendre

Salut,

Si j'ai bien compris tu cherche un moyen d'avoir une fonction qui stocke dans la std::queue des éléments de types différents?

Si c'est ce que tu cherche regarde du côté des template. Un exemple d'une fonction qui peut stocker n'importe quel type de données :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

template <typename T> class Queue {   public : /*.....*/ void stocke(const T& element);   private: std::queue<T> _myQueue; };   ////   template<typename T> void stocke(const T& element) { _myQueue.push(element); }

---

Citation:

---

Envoyé par atm0sfe4r

Salut,

Si j'ai bien compris tu cherche un moyen d'avoir une fonction qui stocke dans la std::queue des éléments de types différents?

Si c'est ce que tu cherche regarde du côté des template. Un exemple d'une fonction qui peut stocker n'importe quel type de données :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

template <typename T> class Queue {   public : /*.....*/ void stocke(const T& element);   private: std::queue<T> _myQueue; };   ////   template<typename T> void stocke(const T& element) { _myQueue.push(element); }

---

---

Il parle d'une collection hétérogène. Ce que tu donnes c'est une collection homogène ;)

voilà c'est ça...car la std::queue donne déjà une forme de pile sous forme template, je pense que je n'aurais pas eu à reimplémenter une file.

Merci quand même! :D

Il serai possible de faire ce que tu veux, mais avec une classe à toi.
Cette classe prend le pointeur sur ton élément à stocker ( void* )
et un flag pour indiquer le type.
Car une fois que tu sors les élément de la queue, il faut que tu sache ce que c'était avant, pour faire le bon cast pour pouvoir réutiliser les éléments...

Je suis en train de l'implémenter merci.
Quand je vais utiliser la file et défiler les éléments par contre, je suppose que je ne pourrais pas faire un simple :

Code:

---

1 2 3 4 5 6

void displayQueue (std::queue<Parameter> paramQueue) { // pour tout les éléments de la file : cout << reinterpret_cast <paramQueue.getType() *> (paramQueue.getValue()) ; // ! }

---

:calim2:

Non car :
1/ getType() retournerait une valeur (un entier ou tout ce que tu veux, mais pas un type.
2/ un paramètre template doit être connu à la compilation : 5, 'a', std::string sont des paramètres template valides (5 est un entier, connu à la compil... de même pour 'a' mais de type char, et std::string est un nom de type qui est connu à la compilation pour peu que <string> soit inclu (indirectement ou directement)).

A la rigueur, std::queue<boost::any> (ou std::queue<boost::variant<T1,T2,T3,T4, ..., TN> > si tu as un nombre *fini* de types que tu veux pouvoir stocker dans ta std::queue).

Mais je pense que ça coince quelque part. Pour quelle raison veux-tu faire ça ? (stocker des éléments de types différents dans un même conteneur)

PS : en C++ sauf si l'on est vraiment obligé, on évite de se trimballer des void*. Les templates et le polymorphisme d'héritage (selon le cas) remplacent avantageusement void*.

Oui c'est bien ce que je pensais...mon programme n'utilise pas Boost, je vais l'installer si je peux. En fait sinon il faudrait tout simplement que je fasse un cast précisément selon le type donné.

Pourquoi tout ça ? car j'ai un module qui fait appel à une dll en donnant successivement des valeurs sous différents types: un nombre fini oui (uchar, int, string, ...) une quinzaine tout au plus. Je dois récupérer ces données pour les traiter à part. A part la file permettant de tout stocker pour l'utiliser ensuite, je ne vois pas comment procéder. J'ai bien d'autres idées mais celle ci me semblait plus appropriée.
Je vais revoir ma conception.

Merci tout de même à tous pour les explications. ;)

Tu peux bien évidemment caster un boost::any/variant vers le type que tu veux... Sauf que tu ne sais pas exactement quel type a l'élément que tu veux récupérer. Donc ça renvoie une exception pour les cast version références, et un pointeur nul pour les versions pointeurs.

J'ai fait une std::queue<Param*> où Param est ma classe dans laquelle on donne une void* value et un string type. Pour réutiliser la file il suffit de recasté dans le bon type connu par le string type donné.
Pour l'instant ça me suffit, j'arrangerai ça plus tard en faisant plus joli...

Merci à tous !
:ccool: