surcharge de modèle de fonction

Quelqu'un peut-il résumer l'idée de la fonction de modèle de la surcharge? Ce qui importe, modèle de paramètre ou les paramètres de la fonction? Que penser de la valeur de retour?

Par exemple, étant donné un modèle de fonction

template<typename X, typename Y> void func(X x, Y y) {}

quelle est la fonction surchargée modèle?

1) template<typename X> void func(X x, int y) {}
2) template<typename X, typename Y> X func(X x, Y y) {}
3) template<class X, class Y, class Z> void func(X x, Y y, Z z) {}

source d'informationauteur skydoor

  1. 22

    De cette liste, seule la seconde introduit une ambiguïté, parce que les fonctions qu'ils sont des modèles qui ne peut pas être surchargé basé sur le type de retour.

    Vous pouvez utiliser les deux autres:

    template<typename X> void func(X x, int y);

    sera utilisé si le deuxième argument de l'appel est un int, e.g func("string", 10);

    template<class X, class Y, class Z> void func(X x, Y y, Z z);

    sera utilisé si vous appelez func avec trois arguments.

    Je ne comprends pas pourquoi certains autres réponses mentionne que le modèle de fonctions et de surcharge de fonctions qui ne se mélange pas. Ils le font certainement, et il y a des règles spéciales l'utilisation de la fonction d'appel est activée.

    14.5.5

    Un modèle de fonction peut être
    surchargé avec d'autres fonction
    modèles et avec la normale
    (non du modèle). Normal
    la fonction n'est pas liée à un
    modèle de fonction (c'est à dire, il n'est jamais
    considérée comme une spécialisation),
    même si elle a le même nom et le type
    en tant que potentiellement générée fonction
    modèle de spécialisation.)

    Un non-basé sur un modèle (ou "moins basé sur un modèle") de surcharge est préféré à des modèles, des e.g

    template <class T> void foo(T);
void foo(int);

foo(10); //calls void foo(int)
foo(10u); //calls void foo(T) with T = unsigned

    Votre premier surcharge avec un non-paramètre du modèle est également sous cette règle.

    Donné le choix entre plusieurs modèles, de plus en plus spécialisée matchs sont privilégiées:

    template <class T> void foo(T);
template <class T> void foo(T*);

int i;
int* p;
int arr[10];

foo(i);  //calls first
foo(p);   //calls second
foo(arr); //calls second: array decays to pointer

    Vous pouvez trouver une description plus formelle de toutes les règles dans le même chapitre de la norme (les modèles de Fonction)

    Et enfin, il y a certaines situations où deux ou plusieurs surcharges d'être ambigu:

    template <class T> void foo(T, int);
template <class T> void foo(int, T);

foo(1, 2);

    Ici l'appel est ambigu, parce que les deux candidats sont également spécialisés.

    Vous pouvez lever l'ambiguïté de telles situations, avec l'utilisation de (par exemple) boost::disable_if. Par exemple, on peut préciser que, lorsque T = int, puis la seconde surcharge ne doit pas être compris comme une surcharge candidat:

    #include <boost/utility/enable_if.hpp>
#include <boost/type_traits/is_same.hpp>
template <class T>
void foo(T x, int i);

template <class T>
typename boost::disable_if<boost::is_same<int, T> >::type
foo(int i, T x);

foo(1, 2); //calls the first

    Ici la bibliothèque de produit de substitution "échec" dans le type de retour de la seconde surcharge, si T = int, le retirer de l'ensemble de la surcharge des candidats.

    Dans la pratique, il est rarement exécuté dans des situations comme ça.

  2. 3

    Il y a deux choses ici: la fonction de création de modèles et de surcharge de fonctions. Deux distincts modèle déclarations sont susceptibles d'être des surcharges de chaque autre, de sorte que votre question n'a pas tout à fait logique comme indiqué. (Les trois "surcharges" vous donnez ne pas construire sur le premier modèle, plutôt que vous avez quatre surcharges pour le même nom de fonction.) Le vrai problème est, compte tenu de certaines surcharges et un appelcomment appeler souhaité en surcharge?

    Tout d'abord, le type de retour ne participent pas à la surcharge de processus, qu'il existe ou non un modèle en cause. Par conséquent, #2 ne sera jamais bien jouer avec #1.

    Deuxièmement, les règles de la fonction de modèle de résolution de surcharge sont différentes de la plus couramment utilisée de la classe template de la spécialisation des règles. Tous deux essentiellement de résoudre le même problème, mais

    • les règles pour les modèles de classe sont plus simples et plus puissants, permettant par exemple de récursivité, et (membre) fonctions ne diffèrent que par le type de retour
    • les règles pour les modèles de fonction permettent au compilateur de comprendre les arguments de modèle à partir de l'argument de fonction des types de

    Vous pourriez être en mesure de résoudre votre problème avec la fonction de modèle de surcharges, mais vous pouvez avoir de la difficulté à la fixation d'un bug qui vient du fait que les règles sont plus longs et moins de gens sont familiers avec leurs subtilités. J'étais pas au courant, après quelques années de modèle de piratage qui subtil de la fonction de modèle de la surcharge était encore possible. Dans les bibliothèques comme Boost et du CCG STL, une approche alternative est omniprésent. Utilisation basé sur un modèle de classe wrapper:

    template< typename X, typename Y >
struct functor {
    void operator()( X x, Y y );
};
template< typename X > //partial specialization: 
struct functor< X, int > { //alternative to overloading for classes
    void operator()( X x, int y );
};

    Maintenant, vous le sacrifice de l'implicite à l'instanciation de la syntaxe (sans les crochets). Si vous voulez le récupérer, vous avez besoin d'une autre fonction

    template< typename X, typename Y > void func( X x, Y y ) {
    return functor< X, Y >()( x, y );
}

    Je serais intéressé à entendre que de surcharge de fonctions ne peut rien faire (en plus de la déduction) que la classe [partiel] la spécialisation peut pas...

    Et puis, bien sûr, votre surcharge #3 ne sera jamais face à l'ambiguïté, car il a un nombre différent d'arguments que n'importe quel autre surcharge.

  3. 1

    En plus des commentaires, certains plus d'informations sur le sujet en Herbe Sutters de l'article Pourquoi Ne Pas Spécialiser Les Modèles De Fonction. Espérons qu'il serait utile, aussi.

  4. 1

    Je suis corrigé - voir les commentaires ci-dessous. Je ne vais pas modifier mon post original, car cela permettrait de supprimer le cadre des réponses. Je remercie les intervenants pour leur contribution et pour avoir eu la gentillesse de ne pas voter moi -

    Envisager la création de modèles pour être comme la macro pré-processeur, qui s'étend #définit avant le compilateur arrive à les voir.

    Le compilateur se "développer" vos paramètres de modèle et ensuite, regardez votre déclaration de fonction. Ainsi, le modèle de paramètre == paramètre de la fonction. Si vous déclarez la même fonction deux fois, vous obtiendrez une erreur.

    Vous posez des questions sur le type de retour. C'est la partie de la fonction "signature". Deux fonctions avec les mêmes paramètres, mais différents types de retour sont deux fonctions différentes.