problème de généricité

Bonjour,
sujet : problème généricité

faire un produit scalaire entre float et int est impossible y a t il une solution pr résoudre ce problème ?

Code:

---

1 2	template <class T> // ceci marche si les type sont omogène T operator *(const Vecteur<T> & v1 ,const Vecteur<T2> & v2) ;

---

merci pr vos propositoin

Il suffit de te faire une petite classe de traits pour ça qui va caluler ton type de retour.

Code:

---

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

template<class T1, class T2> struct dot_product_result { static T1& t1; static T2& t2; typedef typename BOOST_TYPEOF_TPL( t1*t2 ) type; };   template<class T1, class T2> typename dot_product_result<T1,T2>::type operator *(const Vecteur<T> & v1 ,const Vecteur<T2> & v2);

---

La vrai bonne solution, serait d'empaqueter le tout dans un Polymorphic Function Object et de l'appeler dans operator* en utilisant le protocole result_of pour calculer le type de retour.

Ha, l'éternel soucis =). Enfin, ça se résout bien comme l'a montré joel.
Mais sinon avec la prochaine norme y'aura decltype pour justement palier à ce genre de problème.

Code:

---

1 2 3 4

template <typename T1, typename T2> auto operator+(const T1& lhs, const T2& rhs) -> decltype(lhs + rhs) { // ... }

---

Salut,

Citation:

---

Envoyé par Joel F

La vrai bonne solution, serait d'empaqueter le tout dans un Polymorphic Function Object et de l'appeler dans operator* en utilisant le protocole result_of pour calculer le type de retour.

---

Tu peux préciser STP ? Je vois pas trop ce que tu veux dire.

L'idée est de faire un foncteur dont l'operator() est template et dont le type de retour dépend des types templates d'entrée, d'où le nom de Polymorphic Function Object.

Pour arriver à gérer ça propre, on se base sur le protocole result_of et son implantation pre-C++11 si besoin.

Ca donne ça:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

struct dot_product_ { template<class Sig> struct result; template<class This,class T1,class T2> struct result< This( std::vector<T1>,std::vector<T2>) > { static T1& t1; static T2& t2; typedef typename BOOST_TYPEOF_TPL( t1*t2 ) type; };   template<class T1,class T2> inline typename result<dot_product(T1,T2)>::type operator()( T1 const& a, T2 const& b) const { return ...; } };   template<class T1,class T2> inline typename boost::result_of<dot_product_(T1,T2)>::type dot_product( T1 const& a, T2 const& b) { dot_product_ callee; return callee(a,b); }

---

L'avantage est de localiser le calcul et le calcul du type de retour dans une seule entité. On peut aussi faire du Tag Dispatching pour gérer les différents cas de calcul tout en gardant un point d'entrée unique. Enfin, la structure contenant le result_of et le calcul est un parfait foncteur prêt à l'usage pour toute autre fonction ou méta-fonction nécessitant un Callable Object.

Salut,
Ok. Il s'agit donc de regrouper toute la spécialisation au même endroit (dot_product_) au lieu de l'éparpiller à 2 endroits (dot_product_result et operator*), si j'ai bien compris.
Merci pour l'explication et pour ces liens très intéressants.