Discussion :

[Nanoc]

Bonsoir,

J'ai un code utilisant des expressions templates pour une classe de vecteurs. L'implémentation n'est pas exactement la même que celle proposée par Laurent Gomila dans son tutoriel, mais le problème que j'ai rencontré se trouve aussi dans l'implémentation proposée par Laurent.

Lors de la définition de mes opérateurs surchargés, j'ai (notation de Laurent) pour la multiplication l'opérateur suivant:

Code :

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

1
2
3
4
5
 
template <class T>BinaryOp<T, UnaryOp<double, Const>, Mult> operator *(const T& v1, double d)
{
    return MakeMult(v1, MakeConst(d));
}

qui permet de construire un noeud (de l'arbre syntaxique) qui correspond à la multiplication d'un noeud (à gauche) par un nombre (à droite).

En parallèle, j'ai une autre classe qui n'a rien à voir avec les vecteurs précédemment définis mais qui possède elle aussi des opérateurs surchargés. Notamment, un opérateur du type:

Code :

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

1
2
 
A operator*(const A&, double);

Et c'est là que les problèmes apparaissent. Lorsque j'essaye d'utiliser cet opérateur avec une instance de A, le compilateur (GCC 4.4.1) me dit qu'il y a un conflit et qu'il ne sait pas quelle version choisir entre la version dédiée aux vecteurs et celle spécifique à A.

Je ne peux donc pas avoir en même temps des expressions templates et une autre classe surchargeant des opérateurs ! C'est assez ennuyant.

Auriez-vous une solution à ce problème épineux ?

Merci d'avance !

Nanoc

[Goten]

C'est étonnant... Il me semble (je dis semble car je suis pas sur à 100% mais pas loin) que si deux fonctions conviennent et qu'une est template la régle veut que ça soit la non template qui soit appellé.
Faute de mieux sinon faudrait introduire un namespace pour profiter du koenig lookup.

edit : pas une confirmation mais un petit code que tu peux tester :

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
16
17
18
19
20
 
#include <iostream>
 
template <typename T>
void foo(const T& x)
{
    std::cout << "template" << std::endl;
}
 
void foo(const int& x)
{
    std::cout << "non-template" << std::endl;
}
 
int main()
{
    foo(3);
 
    return 0;
}

chez moi c'est bien la non-template qui est appelé.

[Alp]

+1 pour le koenig lookup avec un namespace. Solution élégante et efficace.

[Nanoc]

@Goten: J'aurais du préciser que la classe A est aussi template. Le souci vient de là en fait. Sans template c'est effectivement la bonne version qui est appelée.

Je vais regarder le Koenig lookup alors. Merci.

[Emmanuel Deloget]

@Goten: J'aurais du préciser que la classe A est aussi template. Le souci vient de là en fait. Sans template c'est effectivement la bonne version qui est appelée.

Je vais regarder le Koenig lookup alors. Merci.

Effectivement : comment le compilateur peut-il s'y retrouver, la seule différence étant le type de retour de l'opérateur ? Ton code est finalement proche de celui-ci (TYPE1 et TYP2 sont définis) :

Code :

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

1
2
3
4
5
 
template <class T> TYPE1 operator*(const T& a, double d)
{ ... }
template <class T> TYPE2 operator*(const T& a, double d)
{ ... }

Lorsque tu appelles l'opérateur, tu aura forcément un conflit quelque part.

[TNT89]

J'ai le même problème et pour l'instant j'utilise une solution bête :

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
16
17
18
19
20
21
 
template <class T>
BinaryOp<T, UnaryOp<double, Const>, Mult>
operator *(const Vector<T>& v1, double d)
{
    return MakeMult(v1, MakeConst(d));
}
 
template <class T, ...>
BinaryOp<T, UnaryOp<double, Const>, Mult>
operator *(const UnaryExpression<...>& v1, double d)
{
    return MakeMult(v1, MakeConst(d));
}
 
template <class T, ...>
BinaryOp<T, UnaryOp<double, Const>, Mult>
operator *(const BinaryExpression<...>& v1, double d)
{
    return MakeMult(v1, MakeConst(d));
}

En gros tu spécifies bien que le code ne peut que recevoir des éléments compatibles avec les expressions syntaxiques et ce seulement pour un objet racine de l'arbre syntaxique...

Mais je vais aussi voir du côté du Koening Look up, merci du conseil!!!