La llamada de la función sobrecargada es ambigua

Question

¿Qué significa este mensaje de error?

error: call of overloaded ‘setval(int)’ is ambiguous 
huge.cpp:18: note: candidates are: void huge::setval(unsigned int) 
huge.cpp:28: note:     void huge::setval(const char*) 

Mi código es el siguiente:

#include <iostream> 
#define BYTES 8 
using namespace std ; 

class huge { 
private: 
    unsigned char data[BYTES]; 
public: 
    void setval(unsigned int); 
    void setval(const char *); 
}; 

void huge::setval(unsigned int t) { 
    for(int i = 0; i< BYTES ; i++) { 
     data[i] = t; 
     t = t >> 1; 
    } 
} 

void huge::setval(const char *s) { 
    for(int i = 0; i< BYTES ; i++) 
     data[i] = s[i]; 
} 

int main() { 
    huge p; 
    p.setval(0); 
    return 0; 
} 

Answer 1

El literal 0 tiene dos significados en C++.
Por un lado, es un número entero con el valor 0.
Por otro lado, es una constante de puntero nulo.

Como su función setval puede aceptar int o char*, el compilador no puede decidir qué sobrecarga quiere decir.

La solución más fácil es simplemente lanzar el 0 al tipo correcto.
Otra opción es para asegurar que se prefiere la sobrecarga int, por ejemplo, haciendo el otro una plantilla:

class huge 
{ 
private: 
    unsigned char data[BYTES]; 
public: 
    void setval(unsigned int); 
    template <class T> void setval(const T *); // not implemented 
    template <> void setval(const char*); 
}; 

Answer 2

Uso

p.setval(static_cast<const char *>(0)); 

o

p.setval(static_cast<unsigned int>(0)); 

como lo indica el error, el tipo de 0 es int. Esto se puede convertir fácilmente en unsigned int o const char *. Al hacer el molde manualmente, le está diciendo al compilador qué sobrecarga desea.

Answer 3

moldeada el valor por lo que el compilador sabe que funcionan a llamar:

p.setval(static_cast<const char *>(0)); 

Nota, que tiene un fallo de segmentación en su código después de que se compile (dependiendo de la función que realmente quería llamar)

Answer 4

reemplace p.setval(0); con lo siguiente.

const unsigned int param = 0; 
p.setval(param); 

De esta manera se sabe con certeza de qué tipo es la constante 0.

Answer 5

Esto es ambiguo porque un puntero es solo una dirección, por lo que un int también se puede tratar como un puntero - 0 (an int) se puede convertir a unsigned int o char * igualmente fácilmente.

La respuesta corta es llamar a p.setval() con algo que es inequívocamente uno de los tipos para el que está implementado: unsigned int o char *. p.setval (0U), p.setval ((unsigned int) 0) y p.setval ((char *) 0) compilarán todos.

En general, es una buena idea mantenerse al margen de esta situación, en primer lugar, al no definir funciones sobrecargadas con tipos similares.

Answer 6

La solución es muy sencilla si tenemos en cuenta el tipo de valor constante, que debe ser "sin signo int "en lugar de" int ".

En lugar de:

setval(0) 

Uso:

setval(0u) 

El sufijo "u" indica al compilador que este es un entero sin signo. Entonces, no se necesitaría ninguna conversión, y la llamada no sería ambigua.