Ambigüedad entre constructores sobrecargados

Question

¿Puede alguien explicarme por qué en el siguiente código recibo una llamada ambigua a los constructores sobrecargados en Foo si intento crear una instancia de MyFooC? Mi suposición era que el entero utilizado como un parámetro constructor habría sido promovido a un int sin firmar y se habría resuelto, pero esto es obviamente incorrecto.

template <typename t> class Foo 
{ 
private: 
    t m_Value; 
    unsigned int m_Length; 

public: 
    Foo(const t& Value) : 
     m_Value(Value), 
     m_Length(0) 
    { 
    } 

    Foo(unsigned int Length) : 
     m_Value(static_cast<t>(0)), 
     m_Length(Length) 
    { 
    } 
}; 

int main() 
{ 
Foo<double> MyFooA(32U); 
Foo<double> MyFooB(32.0f); 
//Foo<double> MyFooC(32); 
    return 0; 
} 

Answer 1

Un int se puede convertir tanto en double como en unsigned; ambas son consideradas conversiones de "ampliación" y tienen el mismo rango. Como norma general , cada vez que sobrecarga y una de las sobrecargas es de tipo integral , es una buena idea sobrecargar también en int, para asegurarse de que obtenga lo que desea, y evitar ambigüedades, cuando alguien intenta a pasa una constante integral.

Por cierto: aunque está claro en el contexto de lo que quiere decir, en el estándar de C++, "promoción" tiene un significado muy preciso, y no incluye una conversión de int a unsigned int.

Answer 2

Supongo que el problema es que una int puede convertirse fácilmente en una doble. No conozco especificaciones en C++ que dicten un orden de preferencia para la conversión implícita, por lo que cuando el compilador ve una int que podría ir a la doble o sin firmar, visualiza la llamada como ambigua.