Étrange appel ambigu d'une erreur de fonction surchargée

Question

j'essaie

 void function(int y,int w)
{
    printf("int function");

}


void function(float y,float w)
{
    printf("float function");
}


int main()
{
    function(1.2,2.2);
    return 0;
}
 

Je reçois une erreur d'erreur comme ..

 error C2668: 'function' : ambiguous call to overloaded function
 

et quand j'essaie d'appeler function(1.2,2) ou function(1,2.2) il imprime en tant que " fonction int "

Veuillez préciser quand le function(float y,float w) sera appelé?

Answer 1

Regardez le message d'erreur de gcc:

a.cpp:16: error: call of overloaded ‘function(double, double)' is ambiguous
a.cpp:3: note: candidates are: void function(int, int)
a.cpp:9: note:                 void function(float, float)

Un appel à la fonction nécessiterait la troncature, c'est pourquoi aucun n'est privilégié par rapport à l'autre. Je soupçonne que vous voulez vraiment void function(double y,double w). Rappelez-vous qu'en C/C++, la virgule flottante par défaut type de littéraux et passage de paramètres est double, de ne PAS flotter.

Mise à JOUR

Si vraiment vous ne voulez pas changer la fonction de la signature de flotter à double, vous pouvez toujours utiliser les littéraux typés comme flotteur. Si vous ajoutez le suffixe f pour les nombres à virgule flottante, ils seront dactylographiés flotteur.

Vos exemples seraient alors function(1.2f, 2f) et function(1, 2.2f).

Answer 2

Qu'est-ce que la surcharge d'opérateur?

Sbi de la célèbre surcharge d'Opérateur faq réponses ceci en détail.

Pourquoi les deux function versions de l'OP le droit d'exister?

Remarquez qu'ils prendre différentes paramètre de la fonction des types(int et float), et donc admissible à titre de fonction valide les surcharges.

Qu'est-ce que la résolution de surcharge?

C'est le processus de sélection le plus approprié en fonction de/à l'exploitant par le compilateur de la mise en œuvre. Si une meilleure viable fonction existe et est unique, résolution de surcharge réussit et produit comme résultat. Sinon résolution de surcharge échoue et que l'appel est traité comme mal formé et compilateur fournit un diagnostic. Le compilateur utilise la conversion implicite de la séquence pour trouver le meilleur le match.

C++03 Standard 13.3.3.1 Conversions Implicites:

Une conversion implicite de la séquence est une séquence de conversion utilisés pour convertir un argument dans un appel de fonction, le type du paramètre correspondant de la fonction appelée.

La conversion implicite des séquences peut être l'une des catégories suivantes:

• Une conversion standard de la séquence(13.3.3.1.1)
• Une conversion définie par l'utilisateur de la séquence(13.3.3.1.2)
• Les points de suspension de la conversion de la séquence(13.3.3.1.3)

Notez que chacun de ces sont classés afin de déterminer la meilleure viable fonction. La plus viable fonction est celle dont tous les paramètres ont soit mieux ou égalité de rang conversion implicite séquences que toutes les autres viable fonctions.La norme détaille chacun de ces en détail dans les sections respectives. La conversion standard de la séquence est pertinente dans la présente affaire, il est ainsi résumée:

Avec assez de fond sur la surcharge de résolution.
examinons les exemples de code dans l'OP:

function(1.2,2.2);

Règle importante: 1.2 et 2.2 sont des littéraux et ils sont traités comme un double type de données.

Lors de la conversion implicite des séquences de cartographie:
À la fois le paramètre de la fonction littéraux avec double type de besoin d'une conversion rang pour appeler l' float ou int version et aucun n'est un meilleur match que les autres, ils obtiennent exactement le même sur la conversion rang. Le compilateur est incapable de détecter le plus viable match et il signale une ambiguïté.

function(1.2,2);

Lors de la conversion implicite de la séquence de la cartographie:
L'un des paramètres de la fonction 2 a une correspondance exacte avec l' int fonction de la version, tandis qu'un autre 1.2 a une conversion de rang. Pour la fonction qui prend en float que les paramètres de la conversion implicite des séquences pour les deux paramètres sont de conversion rang.
Donc la fonction qui prend en int version des scores meilleurs que l' float version et c'est le meilleur match et est appelée.

Comment résoudre la surcharge des erreurs d'ambiguïté?

Si vous ne voulez pas de conversion implicite de la séquence de la cartographie à vous jeter hors, il suffit de fournir des fonctions et de les appeler, de telle manière que les paramètres sont une correspondance exacte. Depuis correspondance exacte au cours des scores de tous les autres, Vous avez une garantie définitive de la fonction souhaitée appelé. Dans votre cas, il y a deux façons de le faire:

Solution 1:

Appel de la fonction, de sorte que les paramètres sont en correspondance exacte pour les fonctions disponibles.

function(1.2f,2.2f);

Depuis 1.2f et 2.2f sont traités en tant que float des types qu'ils correspondent exactement à l' float fonction de la version.

Solution 2:

Fournir une fonction de surcharge qui correspond exactement au type de paramètre dans la fonction appelée.

function(double, double){}

Depuis 1.2 et 2.2 sont traités en tant que double la fonction appelée est exact de cette surcharge.

Answer 3

Si vous ne voulez pas (comme expliqué dans la réponse acceptée):

• utilisez des littéraux float, par exemple 1.2f
• ou changez la surcharge existante float en double

Vous pouvez ajouter une autre surcharge qui appelle le float:

 void function(double y, double w)
{
    function((float)y, (float)w);
}
 

Votre code dans main appellera maintenant la fonction ci-dessus, qui appellera la surcharge float .

Answer 4

La surcharge de fonction dans l'exemple ci-dessus a des appels ambigus parce que le type de retour est identique et que le deuxième argument de l'appel de fonction est double, ce qui peut être traité comme un int ou un flottant et le compilateur confond donc avec quelle fonction exécuter.

Answer 5

J'espère que cette aide Ce code est explicite pour toutes les combinaisons

Vous devez envoyer deux float pour appeler une fonction float

 #include<iostream>
#include<stdio.h>

using namespace std;

//when arguments are both int
void function(int y,int w) {
    printf("int function\n");
}

//when arguments are both double
void function(double y, double w) {
    printf("double function\n");
}

//when arguments are both float
void function(float y, float w) {
    printf("float function\n");
}

//when arguments are int and float
void function(int y, float x) {
    printf("int float function\n");
}

//when arguments are float and int
void function(float y,int w) {
    printf("float int function\n");
}

//when arguments are int and double
void function(int y, double w) {
    printf("int double function\n");
}

//when arguments are double and int
void function(double y, int x) {
    printf("double int function\n");
}

//when arguments are double and float
void function(double y, float x) {
    printf("double float function\n");
}

//when arguments are float and double
void function(float y, double x) {
    printf("float double function\n");
}



int main(int argc, char *argv[]) {
    function(1.2,2.2);
    function(1.2f,2.2f);
    function(1,2);
    function(1.2,2.2f);
    function(1.2f,2.2);
    function(1,2.2);
    function(1,2.2f);
    function(1.2,2);
    function(1.2f,2);
    return 0;
}