Chiamata di errore di sovraccarico è ambiguo
L'errore si verifica quando una funzione sovraccarico il compilatore interpreta le funzioni come singola funzione e non può fare una differenza tra le due funzioni sovraccarichi in base ai loro dati. Quindi, possiamo dire che questo errore si verifica a causa dell'incapacità del compilatore di effettuare una selezione tra due metodi giustamente sovraccarichi. Si dice che l'intero processo sia ambiguo perché non è chiaro. Codici e programmi contenenti tali ambiguità non possono compilare e infine generare errori.
Sintassi
Questa non è una funzione o una libreria integrata che stiamo discutendo, piuttosto è un errore e un errore non ha una sintassi specifica. Questo è il messaggio che il compilatore restituisce quando otteniamo il nostro errore.
Errore: Call of sovraccarico 'setval (int)' è ambiguoNota: la parola 'setval (int)' non è costante.
Esempio # 01:
Per avere una migliore comprensione del nostro errore, ora eseguiremo un esempio per ottenere l'errore e successivamente, risolveremo l'errore. Per farlo, abbiamo dichiarato una lezione con il nome di classe1. In Classe1, abbiamo dichiarato dati su char privati senza segno [byte]. Nella sezione pubblica della nostra classe, abbiamo dichiarato due funzioni con lo stesso nome, "Samefunc". Ma abbiamo superato "Unsigned Int" a uno come parametro e "const char" all'altro come parametro in modo da poter sovraccaricare i metodi avendo gli stessi nomi e diversi dati dei parametri. Nel primo "Samefunc", abbiamo stampato "int" con il valore passato ad esso. Nella seconda funzione, abbiamo stampato "char" con il valore passato alla nostra seconda funzione. Con l'uso di un oggetto all'interno della nostra classe, abbiamo chiamato il metodo il metodo principale. Ora eseguiremo il nostro codice per vedere cosa succede.
#includere#define byte 8
Utilizzo dello spazio dei nomi std;
Classe Classe1
privato:
dati char non firmati [byte];
pubblico:
void Samefunc (int);
void Samefunc (const char *);
;
void Class1 :: Samefunc (int t)
cout<<"int"<
void Class1 :: Samefunc (const char *s)
cout<<"char"<
int main ()
Classe1 P;
P.Samefunc (0);
restituzione 0;
Dopo l'esecuzione del nostro codice, il sistema ci ha dato un messaggio di errore. Se diamo un'occhiata al messaggio di errore, possiamo vedere che il messaggio è quasi lo stesso di cui abbiamo discusso in precedenza. L'unica differenza è il nome della funzione. Ti abbiamo detto in precedenza che il nome della funzione continuerà a cambiare a seconda di ciò che hai dichiarato come il nome della tua funzione. Comunque, il sistema ci ha dato l'errore che "Call of Overload è ambiguo". Si pone una domanda che abbiamo passato "0" alla nostra funzione e "0" è un numero intero, quindi perché il sistema ci ha dato questo errore? Scaviamo il motivo e proviamo a risolvere l'errore.
Ora, per risolvere l'errore, non ritineremo di nuovo tutto il nostro codice, abbiamo semplicemente rimosso la parola chiave "non firmata" prima di "int" nella nostra prima funzione. Dopodiché, abbiamo eseguito il nostro codice e il codice è stato eseguito correttamente.
L'errore è stato causato perché il valore "0" ha due significati nel linguaggio C ++. In primo luogo, è un numero intero. In secondo luogo, nel caso dei personaggi, è costante di punta nullo. Il compilatore non è stato in grado di decidere nel nostro caso se il nostro parametro di input fosse un numero intero o un puntatore nullo costante. Stavamo usando due tipi di dati per i nostri metodi int e char. Quindi, il compilatore si è confuso. Dopo aver rimosso la parola chiave, il compilatore ha preso il parametro come intero ed eseguito la funzione con un tipo di dati interi.
Esempio # 02:
Per farti capire meglio l'errore in discussione. Abbiamo eseguito un altro esempio qui. In questo esempio, abbiamo dichiarato due metodi con gli stessi nomi "Addvals". Ma la differenza tra le due funzioni è che uno sta assumendo numeri interi come parametri di input e l'altro sta prendendo galleggianti come parametri di input. Entrambi i metodi hanno lo stesso scopo, stanno assumendo parametri di input e riassume i loro valori. Nel metodo principale, abbiamo stampato il risultato dopo aver eseguito operazioni sui nostri parametri di input. Eseguiremo il nostro codice per controllare l'output.
#includereUtilizzo dello spazio dei nomi std;
int addvals (int x, int y)
restituire x+y;
int addVals (float x, float y)
restituire x+y;
int main ()
cout<
Ancora una volta, il sistema non ci ha dato alcun output. Invece, ha lanciato un messaggio di errore. Il messaggio di errore è di nuovo uguale a quello precedente. Ma il nome della funzione è diverso. In questo caso, abbiamo superato i valori “1.2 "e" 3.4 "alla nostra funzione che è chiaro che questi valori sono galleggianti. Potrebbe sorgere una domanda sul perché il sistema non abbia eseguito il suo lavoro e ci ha dato l'errore. Per ottenere il motivo, cercheremo di risolvere l'errore e farlo otterremo anche la nostra risposta.
Ora, per risolvere l'errore abbiamo messo “1.2f "e" 3.4f "con i nostri parametri. Eseguiremo di nuovo il codice per vedere se questo approccio aiuta o meno nella risoluzione del nostro errore. Eseguiamo di nuovo il nostro codice per vedere cosa succede.
Il sistema non ci ha dato alcun errore questa volta e ha eseguito correttamente il nostro codice. Quindi, il problema nel nostro codice era che non stavamo mettendo "F" nei nostri parametri. Abbiamo ipotizzato che il compilatore li avrebbe letti come valori fluttuanti anziché numeri interi. Ma avevamo torto perché il compilatore identifica tutti i galleggianti come doppi inizialmente a meno che non mettiamo "F" come suffisso. Una volta che abbiamo messo il nostro suffisso, il codice è stato compilato correttamente.
Conclusione
In questa guida, abbiamo discusso di un altro errore che è "Call of Overload (funzione) è ambiguo". Abbiamo discusso del perché si verifica l'errore. Abbiamo anche discusso del concetto di sovraccarico di funzioni per comprendere il nostro errore in modo migliore. Sono stati eseguiti esempi per aiutarti a ottenere una presa migliore sulla risoluzione dell'errore.