surcharge C++ 3 fonction avec différents paramètres (int, * int, & int)

Question

J'ai donc ce devoir à faire "Utiliser la surcharge des fonctions définir 3 fonctions avec le même nom mais avec des variantes différentes (int, int *, int &) cela retournera la racine carrée de la valeur. " Bien je l'ai fait mais je ne sais pas cela me donne cette erreur: "appel ambigu à la fonction surchargée". J'essaie de le réparer, mais pas fan ... Voici mon code, il est assez simple:

#define _CRT_SECURE_NO_WARNINGS 
#include <math.h> 
#include <iostream> 
using namespace std; 

double rad(int); 
double rad(int*); 
double rad(int&); 

int main(){ 
int a,*pt=&a; 
cin>>a; 
cout<<"Radical din "<<a<<" este "<<rad(a)<<endl; 
cout<<"Radical din "<<a<<" este "<<rad(pt)<<endl; 
cout<<"Radical din "<<a<<" este "<<rad(&a)<<endl; 
return 0; 
} 

double rad(int x){ 
    return (sqrt(x)); 
} 
double rad(int *x){ 
    return (sqrt(*x)); 
} 
double rad(int &x){ 
    return (sqrt(x)); 
} 

Answer 1

Compte tenu de ces déclarations:

double rad(int); // (1) 
double rad(int*); // (2) 
double rad(int&); // (3) 

Faire face à (2) est facile. Nous avons un pointeur, ou nous ne le faisons pas, il n'y a pas de confusion possible. La question est alors, avec ce qui se passe:

int a; 
rad(a); 

Eh bien, ici à la fois le travail et (1)(3). Et il n'y a en fait aucune préférence entre les deux où que ce soit dans les règles pour déterminer quel est le meilleur candidat viable! C'est un appel ambigu, donc cela échouera toujours à compiler.

---

Notez qu'il est possible d'appeler explicitement (1) si - par un simple passage dans un int que vous ne pouvez pas prendre une référence à:

rad(4); // calls (1), since neither (2) nor (3) are possible 

Notez également qu'il est possible de appelez (1) ou (3) même avec une variable nommée comme a, mais nous ne pouvons pas compter sur la résolution de surcharge pour le faire. Nous devons explicitement dire au compilateur quelle fonction nous voulons. Et pour ce faire, nous devons jeter le nom:

int a; 
static_cast<double(*)(int)>(rad)(a); // calls (1) explicitly 
static_cast<double(*)(int&)>(rad)(a); // calls (3) explicitly 

Answer 2

int test_val = 5;  

// accept rvalue reference 
double rad(int &&x) { 
    return (sqrt(x)); 
} 
rad(5); 

// accept pointer 
double rad(int *x) { 
    return (sqrt(*x)); 
} 
rad(&test_val); 

// accept lvalue reference 
double rad(int &x) { 
    return (sqrt(x)); 
} 
rad(test_val); 

Answer 3

Un prélude aux autres réponses: appels à

rad(int) 

et

rad(int& x) 

le même aspect - rad (une). La ligne

rad(&a); 

appels rad (int *);

Answer 4

Vous devez utiliser des références rvalue ('int & & ') au lieu de références lvalue (' int &') en troisième cas de ne pas confondre compilateur. Comme ceci:

#define _CRT_SECURE_NO_WARNINGS 
#include <math.h> 
#include <iostream> 
using namespace std; 

double rad(int); 
double rad(int*); 
double rad(int&&); 

int main(){ 
int a,*pt=&a; 
cin>>a; 
cout<<"Radical din "<<a<<" este "<<rad(a)<<endl; 
cout<<"Radical din "<<a<<" este "<<rad(pt)<<endl; 
cout<<"Radical din "<<a<<" este "<<rad(&a)<<endl; 
return 0; 
} 

double rad(int x){ 
    return (sqrt(x)); 
} 
double rad(int *x){ 
    return (sqrt(*x)); 
} 
double rad(int &&x){ 
    return (sqrt(x)); 
}