Discussion :

[bolhrak]

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.

[loufoque]

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.

[Jean-Marc.Bourguet]

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.

[bolhrak]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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)