Discussion :

[xenosender]

Impossible de trouver de la lecture sur le même cas que ce qui me bloque, donc voilà mon probleme :

J'ai les classes suivantes :

Code :

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

1
2
3
 
template<class T> class Idx {...}
template<class T> class spIdx : public Idx<T> {...}

puis les fonctions suivantes :

Code :

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

1
2
3
 
void myfunc(Idx<double> &i1, Idx<double> &i2, Idx<double> &i3);
template<class T> void myfunc(spIdx<T> &i1, Idx<T> &i2, Idx<T> &i3);

Enfin, je fais l'appel suivant :

Code :

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

1
2
3
4
 
spIdx<double> sptest(0, 4, 4);
Idx<double> x(4), y(4);
myfunc(sptest, x, y);

J'obtiens alors l'erreur suivante :
" erreur: call of overloaded «myfunc(ebl::spIdx<double>&, ebl::Idx<double>&, ebl::Idx<double>&)» is ambiguous
note: candidats sont: void myfunc(ebl::spIdx<T>&, ebl::Idx<T>&, ebl::Idx<T>&) [with T = double]
note: void myfunc(ebl::Idx<double>&, ebl::Idx<double>&, ebl::Idx<double>&) "

Comment régler ce problème ? et pourquoi le compilateur ne choisit-il pas la version dont la signature (bien que templatée) correspond (appel à la sous-classe spIdx) ?
J'ai essayé de caster la variable dans son propre type lors de l'appel à la fonction (ie idx_m2dotm1(static_cast<spIdx<double>&>(sptest), x, y);

Bien evidemment je ne veux pas changer le nom des fonctions, le but étant que l'utilisateur n'aie pas à se soucier de la classe utilisée...

[JolyLoic]

Du point de vue des opération à faire pour convertir les arguments de la fonction, la version templatée est meilleure que la non templatée. Mais la non templatée est aussi possible, et en tant que non templatée, elle aurait tendance à être préférée. D'où l'ambiguïté (d'ailleurs, avec un oeil naïf, j'aurais crus que c'était la non templatée qui serait prise, alors que tu pensais que ce serait l'autre... C'est donc une bonne chose que le compilateur refuse de compiler, non ?)

La solution ? Il y en a peut-être d'autres à base de SNIFAE, mais ce qui me vient en tête en premier est de donner au compilateur une fonction qui soit clairement meilleure que ces deux là, et il la prendra sans hésiter :

Code :

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

void myfunc(spIdx<double> &i1, Idx<double> &i2, Idx<double> &i3);

[xenosender]

Ca marche effectivement, mais... j'ai quand même du mal à comprendre pourquoi les 2 opérations sont considérées "du même niveau" par le compilateur...
Bref, cas résolu

[JolyLoic]

Les règles précises de surcharge sont assez complexes. Pour déterminer si une fonction est meilleur qu'une autre :

Define ICSi(F) as follows:
— if F is a static member function, ICS1(F) is defined such that ICS1(F) is neither better nor worse than ICS1(G) for any function G, and, symmetrically, ICS1(G) is neither better nor worse than ICS1(F)122);
otherwise,
— let ICSi(F) denote the implicit conversion sequence that converts the ith argument in the list to the type of the ith parameter of viable function F. 13.3.3.1 defines the implicit conversion sequences and 13.3.3.2 defines what it means for one implicit conversion sequence to be a better conversion sequence or worse conversion sequence than another.
Given these definitions, a viable function F1 is defined to be a better function than another viable function F2 if for all arguments i, ICSi(F1) is not a worse conversion sequence than ICSi(F2), and then
— for some argument j, ICSj(F1) is a better conversion sequence than ICSj(F2), or, if not that,
— F1 is a nontemplate function and F2 is a template function specialization, or, if not that,
— F1 and F2 are template functions, and the function template for F1 is more specialized than the template for F2 according to the partial ordering rules described in 14.5.5.2, or, if not that,
— the context is an initialization by userdefined conversion (see 8.5, 13.3.1.5) and the standard conversion sequence from the return type of F1 to the destination type (i.e., the type of the entity being initialized)
is a better conversion sequence than the standard conversion sequence from the return type of F2 to the destination type. [Example:

Code :

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

1
2
3
4
5
6
7
8
9
10
struct A {
A();
operator int();
operator double();
} a;
int i = a; // a.operator int() followed by no conversion
// is better than a.operator double() followed by
// a conversion to int
float x = a; // ambiguous: both possibilities require conversions,
// and neither is better than the other

—end example]
2 If there is exactly one viable function that is a better function than all other viable functions, then it is the one selected by overload resolution; otherwise the call is illformed123).

Suivent les règles définissant les séquences de conversion...

C'est expliqué en détails dans "C++ templates, the complete guide" de Jossutis et Vandervoorde.

[Jean-Marc.Bourguet]

Les versions de g++ que j'ai essayé, ainsi que Sun CC préfèrent bien la version template. C'est avec quel compilateur que tu as essayé?

[xenosender]

g++ 4.2.3 pourtant, via eclipse IDE sous ubuntu...