template et conversion implicite

Bonjour,

un petit souci avec les conversions implicites. J'ai un operator du type :

Code:

---

1 2 3 4 5

template <class E1, class E2> untype<E1, E2> operator+(const hybrid_expression<E1>& e1, const scalar_expression<E2>& e2) { //... }

---

Avec scalar_expression une classe contenant un constructeur de conversion :

Code:

---

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

template <class E> class scalar_expression {   public:   scalar_expression(const E& e) : m_e(e) {}   private:   const E& m_e; };

---

Mais quand je fais l'appel :

Code:

---

1 2	V1 = V2 + 4;

---

Avec V1 et V2 des types dérivants de hybrid_expression, le compilo ne trouve pas d'oérateur adéquat. Ca passe uniquement si je fais un opérateur du type :

Code:

---

1 2 3 4 5

template <class E> un_type<E, int> operator+(const hybrid_expression<E>& e1, const int& e2) { //... }

---

Apparemment le fait que l'argument de l'opérateur soit un template empêche la résolution de type. J'ai essayé également de passer par une classe de traits spécialisée du style :

Code:

---

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

template <class E> class scalar_traits;   template <> class scalar_traits<int> { typedef int type; }   template <class E1, class E2> untype<E1, E2> operator+(const hybrid_expression<E1>& e1, const typename scalar_traits<E2>::type& e2) { //... }

---

Même problème. Quelqu'un aurait une idée ?

Merci d'avance.

Citation:

---

Apparemment le fait que l'argument de l'opérateur soit un template empêche la résolution de type.

---

En effet, car il serait nécessaire d'instancier la fonction template pour savoir depuis quoi les arguments peuvent être construits, or pour l'instancier il te faut déduire ce type.

Citation:

---

Envoyé par bolhrak

Apparemment le fait que l'argument de l'opérateur soit un template empêche la résolution de type.

---

Tu veux faire correspondre un int à un const scalar_expression<E2>&. L'algorithme utilisé pour la déduction des types templates (donc de ce que vaut E2) ne permet que très peu de conversions (ajout dans certains cas de const/volatile et dérivée->base) et pas celles définies par l'utilisateur.

Merci pour vos réponses. Cela m'a fait chercher une autre piste, et le problème est résolu.

Ce code était là pour remplacer le code suivant :

Code:

---

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

template <class E1, class E2> un_type operator+(const hybrid_expression<E1>& e1, const hybrid_expression<E2>& e2) { //... }   template <class E1, class E2> un_type1 operator+(const hybrid_expression<E1>& e1, const E2& e2) { //... }   template <class E1, class E2> un_type2 operator+(const E1& e1, const hybrid_expression<E2>& e2) { //... }

---

Code qui me sortait une erreur lorsque je tentais d'additionner deux hybrid_expression, me disant que trois operator+ correspondaient.

En utilisant la mpl et en enlevant les deux derniers opérateurs du Set de surcharge lorsque les arguments dérivent de hybrid_expression, tout marche nickel :

Code:

---

1 2 3 4 5 6 7 8 9 10

template <class E1, class E2> typename boost::disable_if<mpl::and_<boost::is_base_of<hybrid_expression<E1>, E1>, boost::is_base_of<hybrid_expression<E2>, E2> un_type1>::type operator+(const hybrid_expression<E1>& e1, const E2& e2) { //... }   //La meme chose pour operator+(const E1& e1, const hybrid_expression<E2>& e2)

---