Bonjour,

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

Code : Sélectionner tout - Visualiser dans une fenêtre à part
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 : Sélectionner tout - Visualiser dans une fenêtre à part
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 : Sélectionner tout - Visualiser dans une fenêtre à part
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 : Sélectionner tout - Visualiser dans une fenêtre à part
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 : Sélectionner tout - Visualiser dans une fenêtre à part
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.