L'appel d'erreur de surchargé est ambigu
L'erreur se produit lorsqu'une fonction surchargeant le compilateur interprète les fonctions comme une seule fonction et ne peut pas faire la différence entre les deux fonctions surchargées en fonction de leurs données. Nous pouvons donc dire que cette erreur se produit en raison de l'incapacité du compilateur à faire une sélection entre deux méthodes à juste titre surchargées. On dit que tout ce processus est ambigu car il n'est pas clair. Les codes et programmes contenant de telles ambiguïtés ne peuvent pas compiler et finalement générer des erreurs.
Syntaxe
Ce n'est pas une fonction ou une bibliothèque intégrée dont nous discutons, c'est plutôt une erreur, et une erreur n'a pas de syntaxe spécifique. C'est le message que le compilateur renvoie lorsque nous obtenons notre erreur.
Erreur: l'appel de «setval (int)» surchargé est ambiguRemarque: le mot «setval (int)» n'est pas constant.
Exemple # 01:
Pour mieux comprendre notre erreur, nous allons maintenant effectuer un exemple pour obtenir l'erreur et après cela, nous résoudrons l'erreur. Pour ce faire, nous avons déclaré une classe avec le nom Class1. Dans la classe 1, nous avons déclaré des données de char non signées privées [octets]. Dans la section publique de notre classe, nous avons déclaré deux fonctions avec le même nom, «Samefunc». Mais nous avons transmis «unsigned int» à l'un comme paramètre et «const char» à l'autre en tant que paramètre afin que nous puissions surcharger les méthodes en ayant les mêmes noms et différents données que les paramètres. Dans le premier «Samefunc», nous avons imprimé «int» avec la valeur qui lui est transmise. Dans la deuxième fonction, nous avons imprimé «char» avec la valeur transmise à notre deuxième fonction. Avec l'utilisation d'un objet dans notre classe, nous avons appelé la méthode la méthode principale. Maintenant, nous allons exécuter notre code pour voir ce qui se passe.
#inclure#define octets 8
Utilisation de Namespace Std;
classe Classe1
privé:
Données de char non signées [octets];
public:
void Samefunc (int);
void Samefunc (const char *);
;
void class1 :: Samefunc (int t)
couter<<"int"<
void class1 :: Samefunc (const char * s)
couter<<"char"<
int main()
classe 1 p;
p.Samefunc (0);
retour 0;
Après l'exécution de notre code, le système nous a donné un message d'erreur. Si nous jetons un œil au message d'erreur, nous pouvons voir que le message est presque le même que nous avons discuté plus tôt. La seule différence est le nom de la fonction. Nous vous avons dit plus tôt que le nom de la fonction continuerait de changer en fonction de ce que vous avez déclaré comme le nom de votre fonction. Quoi qu'il en soit, le système nous a donné l'erreur que «l'appel de surcharge est ambigu» ». Une question se pose que nous avons transmis «0» à notre fonction et «0» est un entier, alors pourquoi le système nous a-t-il donné cette erreur? Découchons la raison et essayons de résoudre l'erreur.
Maintenant, pour résoudre l'erreur, nous ne retaperons pas notre code entier à nouveau, nous avons simplement supprimé le mot-clé «non signé» avant «int» dans notre première fonction. Après cela, nous avons exécuté notre code et le code a été exécuté avec succès.
L'erreur a été causée parce que la valeur «0» a deux significations dans la langue C ++. Premièrement, c'est un entier. Deuxièmement, dans le cas des caractères, c'est une constante de pointeur nul. Le compilateur n'a pas pu décider dans notre cas si notre paramètre d'entrée était un entier ou une constante de pointeur nul. Nous utilisons deux données pour nos méthodes INT et CHAR. Donc, le compilateur a été confus. Après avoir supprimé le mot-clé, le compilateur a pris le paramètre comme un entier et a exécuté la fonction avec un type de données entier.
Exemple # 02:
Pour vous faire mieux comprendre l'erreur discutée. Nous avons effectué un autre exemple ici. Dans cet exemple, nous avons déclaré deux méthodes avec les mêmes noms «addvales». Mais la différence entre les deux fonctions est que l'un prend des entiers comme paramètres d'entrée et l'autre prend des flotteurs comme paramètres d'entrée. Les deux méthodes ont le même but, ils prennent des paramètres d'entrée et résument leurs valeurs. Dans la méthode principale, nous avons imprimé le résultat après avoir effectué des opérations sur nos paramètres d'entrée. Nous exécuterons notre code pour vérifier la sortie.
#inclureUtilisation de Namespace Std;
int addvals (int x, int y)
retour x + y;
int addvals (float x, float y)
retour x + y;
int main()
couter<
Encore une fois, le système ne nous a donné aucune sortie. Au lieu de cela, il a lancé un message d'erreur. Le message d'erreur est à nouveau le même que le précédent. Mais le nom de la fonction est différent. Dans ce cas, nous avons transmis des valeurs «1.2 ”et« 3.4 ”à notre fonction, ce qui est clair que ces valeurs sont des flotteurs. Une question peut se poser pourquoi le système n'a pas effectué son travail et nous a donné l'erreur. Pour obtenir la raison, nous essaierons de résoudre l'erreur et ce faisant, nous obtiendrons également notre réponse.
Maintenant, pour résoudre l'erreur que nous avons mis «1.2f ”et« 3.4f ”avec nos paramètres. Nous exécuterons à nouveau le code pour voir si cette approche aide à la résolution de notre erreur ou non. Exécutons à nouveau notre code pour voir ce qui se passe.
Le système ne nous a donné aucune erreur cette fois et a exécuté avec succès notre code. Donc, le problème dans notre code était que nous ne mettons pas «F» dans nos paramètres. Nous avons supposé que le compilateur les lirait comme des valeurs flottantes au lieu des entiers. Mais nous avions tort parce que le compilateur identifie tous les flotteurs comme doublé au départ à moins que nous mettions «F» comme un suffixe. Une fois que nous avons mis notre suffixe, le code a été compilé avec succès.
Conclusion
Dans ce guide, nous avons discuté d'une autre erreur qui est «l'appel de surcharge (fonction) est ambigu» ». Nous avons expliqué pourquoi l'erreur se produit. Nous avons également discuté du concept de surcharge de fonction pour comprendre notre erreur d'une meilleure manière. Des exemples ont été effectués pour vous aider à obtenir une meilleure prise sur la résolution de l'erreur.