Correspondance d'argument
Les fonctions surchargées sont sélectionnées pour la meilleure correspondance des déclarations de fonction dans la portée actuelle aux arguments fournis dans l'appel de fonction.Si une fonction appropriée est trouvée, cette fonction est appelée. "Approprié » dans ce contexte signifie une des opérations suivantes :
Une correspondance exacte a été trouvée.
Une conversion ordinaire a été exécutée.
une promotion intégrale a été effectuée.
Une conversion standard au type d'argument souhaité existe.
Une conversion définie par l'utilisateur (opérateur ou le constructeur de conversion) au type d'argument souhaité existe.
Les arguments représentés par des ellipses ont été trouvés.
Le compilateur crée un ensemble de fonctions candidates pour chaque argument.Les fonctions candidates sont des fonctions dans lesquelles l'argument réel dans cette position peut être convertie dans le type de l'argument formel.
Un ensemble d'« meilleures fonctions de correspondance » est généré pour chaque argument, et la fonction sélectionnée est l'intersection de tous les jeux.Si l'intersection contient plusieurs fonctions, la surcharge est ambiguë et génère une erreur.La fonction qui est finalement sélectionnée est toujours une meilleure correspondance que chaque autre fonction au groupe pour au moins un argument.si ce n'est pas le cas (s'il n'y a aucun clair vainqueur), l'appel de fonction génère une erreur.
Considérez les déclarations suivantes (fonctions sont Variant 1marqué, Variant 2, et Variant 3, pour l'ID dans la discussion suivante) :
Fraction &Add( Fraction &f, long l ); // Variant 1
Fraction &Add( long l, Fraction &f ); // Variant 2
Fraction &Add( Fraction &f, Fraction &f ); // Variant 3
Fraction F1, F2;
considérez l'instruction suivante :
F1 = Add( F2, 23 );
Les générations précédentes d'instruction deux jeux :
ensemble 1 : Fonctions candidates qui ont le premier argument de la fraction de type |
ensemble 2 : Fonctions candidates dont le deuxième argument peut être converti en type int |
|---|---|
Variant 1 |
Variant 1 (int peut être converti en long à l'aide d'une conversion standard) |
Variant 3 |
|
Les fonctions dans l'ensemble 2 sont des fonctions pour lesquelles il existe des conversions implicites de type de paramètre actuel en type de paramètre formel, et entre de ces fonctions il existe une fonction qui « coûte » de convertir le type de paramètre actuel à son type de paramètre formel est le plus petit.
L'intersection de ces deux jeux est 1. variant.Un exemple d'appel de fonction ambigu est :
F1 = Add( 3, 6 );
L'appel de fonction précédent génère des ensembles suivants :
ensemble 1 : Fonctions candidates qui ont le premier argument de type int |
ensemble 2 : Fonctions candidates qui ont le deuxième argument de type int |
|---|---|
Variant 2 (int peut être converti en long à l'aide d'une conversion standard) |
Variant 1 (int peut être converti en long à l'aide d'une conversion standard) |
notez que l'intersection entre ces deux ensembles est vide.par conséquent, le compilateur génère un message d'erreur.
Pour la correspondance d'argument, une fonction avec des arguments par défaut de n est traitée comme n+1séparent les fonctions, chacun avec un nombre différent d'arguments.
les points de suspension (...) agissent en tant que caractère générique ; ils correspondent tout argument réel.Cela peut entraîner de nombreux jeux ambigus, si vous ne concevez pas vos ensembles surchargés de fonction avec prudence extrême.
[!REMARQUE]
L'ambiguïté les fonctions surchargées ne peut pas être déterminée jusqu'à ce qu'un appel de fonction est produit.À ce stade, les jeux sont générés pour chaque argument dans l'appel de fonction, et déterminer si une surcharge non équivoque existe.Cela signifie que les ambiguïtés peuvent rester dans votre code jusqu'à ce qu'elles soient évoquées par un appel de fonction spécifique.