résolution de surcharge dans les modèles

Question

Tout expliquer cela par un exemple

"Involving conversions on a function argumentsinvolved in template 
    parameter deduction." 

exeMPLeS comme ceci:

template<class T> struct B { /* ... */ }; 
template<class T> struct D : public B<T> { /* ... */ }; 
template<class T> void f(B<T>&); 
void g(B<int>& bi, D<int>& di) 
    { 
    f(bi); 
    f(di); 
    } 

S'il vous plaît me donner quelques exemples

EDIT: Il est un point/déclaration à partir de la norme ISO C++ 14.8.3/5e: résolution de surcharge

Answer 1

Il s'agit de ce que l'exemple montre. En somme, ce sont les conversions

• Le paramètre de fonction peut être un Base<T>, tandis que l'argument de la fonction est un Derived<T>. Comparer avec ifstream << "hello" - le côté gauche de operator<< est déduit de cette façon.
• Le paramètre de la fonction peut être un const U&, tandis que l'argument de la fonction est un U (identique pour le volatile).
• Le paramètre de la fonction peut être un const U* ou un const E C::* alors que l'argument de la fonction est un U* ou E C::* respectivement (il s'agit des conversions de qualification) - même pour les volatiles.

D'autres conversions ne peuvent pas être effectuées pour un paramètre/argument de fonction qui participe à la déduction. Toute la gamme de conversions peut être appliquée si un paramètre de fonction participe à la déduction, mais cela nécessite un contexte non déduit ou un contexte où il n'y a pas d'argument à déduire du tout, et l'implémentation n'est pas vraiment d'accord il (voir here).

En d'autres termes:

template<typename T> struct id { typedef T type; }; 
template<typename T> void f(T, typename id<T>::type); 

int main() { 
    // deduction acts on void(int*, int*) - deduction does not need 
    // to deduce anything and follows [temp.arg.explicit]p4 
    f<int*>(0, 0); 

    // deduction acts on void(T, id<T>::type) - second is a non-deduced context, 
    // which *will* allow the conversion of int -> int*, since it will not compare 
    // the argument with parameter during deduction (since it is non-deduced). 
    f((int*)0, 0); 
} 

Le deuxième exemple est vital pour some partial ordering contextes de travail.