Correspondance d'arguments
Les fonctions surchargées sont sélectionnées pour la meilleure correspondance des déclarations de fonction de la portée actuelle avec les arguments fournis dans l'appel de fonction. Si une fonction appropriée est trouvée, elle est appelée. Dans ce contexte, le terme « approprié » a l'une des significations suivantes :
Une correspondance exacte a été trouvée.
Une conversion ordinaire a été exécutée.
Une promotion intégrale a été exécutée.
Une conversion standard vers le type d'argument souhaité existe.
Une conversion définie par l'utilisateur (opérateur de conversion ou constructeur) vers le type d'argument souhaité existe.
Des arguments représentés par une ellipse ont été détecté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 converti vers le type de l'argument formel.
Un ensemble des « meilleures fonctions correspondantes » est généré pour chaque argument, et la fonction sélectionnée correspond à l'intersection de tous les ensembles. Si l'intersection contient plusieurs fonctions, la surcharge est ambiguë et génère une erreur. La fonction qui est sélectionnée en finalité constitue toujours une meilleure correspondance que chaque autre fonction du groupe pour au moins un argument. Dans le cas contraire (en l'absence d'un vainqueur clair), l'appel de fonction génère une erreur.
Prenons les déclarations suivantes (les fonctions sont marquées Variant 1, Variant 2 et Variant 3, afin de les identifier 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;
Prenons l'instruction suivante :
F1 = Add( F2, 23 );
L'instruction précédente génère deux ensembles :
Ensemble 1 : Fonctions candidates qui comportent le premier argument de type fraction |
Ensemble 2 : Fonctions candidates dont le second argument peut être converti en type int |
|---|---|
Variant 1 |
Variant 1 (int peut être converti en long via une conversion standard) |
Variant 3 |
|
Les fonctions dans l'ensemble 2 sont des fonctions pour lesquelles il existe des conversions implicites du type de paramètre réel au type de paramètre formel, et parmi ces fonctions, il en existe une pour laquelle le « coût » de conversion du type de paramètre réel en type de paramètre formel est le plus petit.
L'intersection de ces deux ensembles est Variant 1. Voici un exemple d'appel de fonction ambigu :
F1 = Add( 3, 6 );
L'appel de fonction précédent génère les ensembles suivants :
Ensemble 1 : Fonctions candidates qui comportent le premier argument de type int |
Ensemble 2 : Fonctions candidates qui comportent le second argument de type int |
|---|---|
Variant 2 (int peut être converti en long via une conversion standard) |
Variant 1 (int peut être converti en long via 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 n est traitée comme des fonctions séparées n+1, chacune ayant un nombre d'arguments différent.
L'ellipse (...) fait office de caractère générique ; elle correspond à n'importe quel argument réel. Cela peut aboutir à de nombreux ensembles ambigus si vous ne concevez pas vos ensembles de fonctions surchargées de fonction avec une extrême prudence.
Notes
L'ambiguïté des fonctions surchargées ne peut pas être déterminée tant qu'un appel de fonction n'est pas détecté.À ce stade, les ensembles sont générés pour chaque argument dans l'appel de fonction, et vous pouvez 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 particulier.