Réponse

Historique de la question

C++ a été conçu dès le début comme un langage supportant la surcharge de fonctions — la possibilité de déclarer plusieurs fonctions avec le même nom mais avec des paramètres différents. Cela permet de créer une API lisible et pratique.

Problème

Lorsque le nombre de fonctions avec le même nom augmente, le compilateur doit choisir la bonne implémentation parmi toutes les surcharges, en tenant compte des types d'arguments, des conversions, des paramètres par défaut et des références. Avec une surcharge négligente, des ambiguïtés et des erreurs difficilement détectables peuvent survenir.

Solution

Le compilateur choisit la fonction sur la base du meilleur correspondance de la séquence d'arguments, de la précision d'appariement des types et des conversions minimales. Cependant, il faut tenir compte des nuances : s'il y a des conversions significatives ou des arguments par défaut, une ambiguïté peut survenir de façon inattendue.

Exemple de code :

void foo(int x);
void foo(double x);
void foo(int x, int y = 0);

foo(5); // appellera void foo(int x), car c'est une correspondance exacte
foo(5.2); // appellera void foo(double x)
foo(5, 6); // appellera void foo(int x, int y)

Caractéristiques clés :

Toutes les fonctions doivent se différencier par un ensemble unique de types/nombre de paramètres
Les arguments par défaut pour les fonctions surchargées peuvent compliquer la résolution de surcharge
Les références et les conversions de types peuvent provoquer des ambiguïtés

Questions pièges.

Peut-on surcharger des fonctions uniquement par le type de retour ?

Non. La surcharge est possible UNIQUEMENT par le type et le nombre de paramètres, le type de retour n'intervient pas dans la résolution de surcharge.

int foo();
double foo(); // Erreur : la surcharge uniquement par type de retour n'est pas possible !

Comment le compilateur choisit-il quelle fonction surchargée appeler si tous les paramètres sont convertibles ?

Le compilateur choisit la "meilleure correspondance" — la fonction pour laquelle le nombre minimal de conversions de types est requis, ou une correspondance exacte. S'il existe une ambiguïté, le code ne se compilera pas.

void bar(int);
void bar(long);
bar(1); // int correspondance exacte : appellera bar(int)

Peut-on mélanger la surcharge basée sur des arguments par défaut et la surcharge normale ?

Oui, mais des ambiguïtés d'appel peuvent survenir si les signatures des fonctions se chevauchent.

void test(int x);
void test(int x, int y = 10);

test(5); // Erreur : ambiguïté — les deux conviennent

Erreurs typiques et anti-patterns

Intersection des fonctions surchargées avec des paramètres par défaut
Conversion de types peu évidente (par exemple, double → int)
Tentative de surcharge uniquement par type de retour

Exemple de la vie réelle

Cas négatif

Dans la bibliothèque, des fonctions surchargées avec des arguments par défaut se chevauchent, ce qui entraîne des erreurs de compilation lors de la mise à jour du code.

Avantages :

au début, il est facile d'appeler des fonctions

Inconvénients :

erreurs lorsque de nouvelles surcharges avec des arguments similaires sont ajoutées
comportement imprévisible dû à l'auto-choix des surcharges

Cas positif

Dans le projet, une convention a été établie — ne pas mélanger les surcharges avec des arguments par défaut, ou utiliser soit une seule fonction avec des valeurs par défaut, soit surcharger exclusivement par des paramètres uniques.