[template] peut on connaitre le type dynamique ?

Bonjour,

bon je rois que ma question est posée.
Mais je vais la reformuler en bon françois. En fait peut on connaitre le type dynamique d'un parametre template via typeid de typeinfo ?
C'est bete mais je trouve pas de doc melant les deux notions. Sans ca et ben et ben, je crois qu'il va falloir revoir ma stratégie

Bon sur ce la journée se finie je souhaite une bonne soirée a tous ceux qui liront ce mail, et encore plus a ceux qui y répondront

Merci

--------------------------------------------------------------------------
Bjarne a dit :
"C makes it easy to shoot yourself in the foot.
C++ makes it harder, but when you do,
it blows away your whole leg"

Tu veux faire quoi exactement avec ce type ?

En général avec les templates on parle de type statique, il n'y a que le polymorphisme qui introduit une différence entre type statique et type dynamique. Donc soit tu emploies le mauvais vocabulaire, soit tu veux bien récupérer le type dynamique d'un objet mais dans ce cas cela n'a rien à voir avec les templates. Pour récupérer le type statique, c'est typeid(), mais cela ne te permettra pas de faire grand chose.

Si tu nous disais plutôt pourquoi tu veux faire ça ?

en fait suivant le type du param je l envoi dans differentes listes

si un int
alors ma_liste_de_int.add(param)
sinon ma_liste_de_double.add(param)

voila le principe suivant le type je n appel pas les meme méthodes[/code]

Ok, on parle donc bien du type statique. Tu peux toujours bidouiller avec typeid(), mais personnellement c'est bien la dernière chose que je ferais. Le mieux serait d'avoir non pas liste_de_int et liste_de_double, mais liste_de<int> et liste_de<double>.

Après faut voir le contexte si tu veux qu'on puisse mieux te conseiller, mais dans tous les cas tu devrais repenser un peu ton design.

A tout hasard tu peux lire ça :

http://loulou.developpez.com/tutorie.../partie4/#L3.2

On peut pas le faire avec la surcharge des fonctions ?

Code:

---

1 2 3 4 5 6 7 8

void Ajouter_dans_liste (int x) { ma_liste_de_int.add(x); return ; } void Ajouter_dans_liste (double x) { ma_liste_de_double.add(x); return ; }

---

Clairement, avant d'arriver à des solutions abracadabrantes revoir l'architecture me paraît plus que conseillé. Personnellement, j'ai suivi ton précédent topic et je ne comprends toujours pas ce que tu souhaites faire.

Si vraiment tu dois executer un code différent en fonction du type. Et que tu ne peux pas executer le même code paramétré par le type (cf. solution de Loulou), alors tu peux spécialiser partiellement la méthode générique appelée.
Pour ce qui est des spécialisations partielle, voir le méga-cours de Casteyde sur ce site.

Bon reprenons, je sais j'explique mal :oops: :oops: :oops:

Contrainte de la boite, il faudrai que le mec a l'ihm puisse en cliquant selon le données génere un objet. Suivant les ihm il genere divers objet. Il faudrai qu il puisse tout le temps faire

<<static>> ClasseX.ajouter(objet)

probleme, on aurai pu concevoir un heritage commun a tous les objets, mais c est pas possible deja developpé. :snif:

Ensuite suivant l'objet il faudrai faire 2 redirection pour aboutir a :

list<ObjetTypé>.ajouter(ObjetTypé)

une redirection vers la classe qui gère l'objets qui gere la bonne liste et ensuite vers la classe qui gère LA bonne liste.(je peux pas regrouper mes listes dans la meme classe)

voila, desolé, c'est long, le probleme viens d'ailleurs mais j'espère avoir été un peu plus clairs

Merci de votre attention

----------------------------------------------------------------
"C makes it easy to shoot yourself in the foot.
C++ makes it harder, but when you do,
it blows away your whole leg" (Bjarne Stroustrup)
(Avec le C c'est facile de se tirer dans le pied
avec le C++ c'est plus dur, mais si tu le fais,
ca te pète toute la jambe)

Ok, ben si ce n'est que ça tu peux utiliser la spécialisation de template comme te l'a suggéré VoidSeer.

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

template <class T> void Ajouter(const T& Obj) { // Comportement par défaut, ou pas de corps si jamais appelé }   template <> voidAjouter<int>(const int& Obj) { liste_de_int.ajouter(Obj); }   template <> voidAjouter<double>(const double& Obj) { liste_de_double.ajouter(Obj); }

---

Merci a tous pour votre temps et vos réponse.

LouLou, ta solution semble correspondre et convenir, je vais essayé

Merci !!!

J'ai toujours un petit peu de mal à saisir le problème, mais vu qu'il n'existe aucune relation d'héritage entre les entités n'est-t-il pas possible de s'en sortir uniquement avec de la surcharge de fonction ?
En créant une classe d'aiguillage avec uniquement des méthodes statique genre:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

class Router { public: static void add(classX&, classA&) ; static void add(classX&, classB&);   static void add(classY&, classA&); static void add(classY&, classB&);   ... private: Router(); }

---

L'appel, au lieu d'être direct

Code:

---

ClassX.ajouter(ClassA)

---

se transforme en

Code:

---

Router::add(y, a)

---

Une fois dans la méthode add(...), tous les types sont connus. On peut donc appeler les bonnes méthodes.

Code:

---

1 2 3 4

void Router::add(classY& x, classA& a) { y.ajouter_ds_liste_A(a); }

---