C++ compiler error: ambiguous call to overloaded function

string aux;
int maxy,auxx=0;

cin>>aux;

maxy= (int)sqrt(aux.开发者_运维知识库size());

I'm geting:

1> error C2668: 'sqrt' : ambiguous call to overloaded function
1>        could be 'long double sqrt(long double)'
1>        or       'float sqrt(float)'
1>        or       'double sqrt(double)'

Why?

---

string::size() returns size_t, and sqrt doesn't accept it in any of its versions. So the compiler has to cast, and cannot choose to what - all of them are OK. You have to put explicit cast:

maxy = (int)sqrt((double)aux.size());

---

The problem is that in C++, there are three functions named sqrt - one taking in a float, one taking a double, and one taking a long double. When you try calling

sqrt(aux.size());

The compiler tries to determine which of these functions you want to call. Since aux.size() returns a string::size_type, which is neither a float, double, nor long double, it tries to see if string::size_type is implicitly convertible to any of these three. But since string::size_type is convertible to all three of these types, the compiler marks the call as ambiguous, since it's unclear which of the conversions you want to do.

To fix this, you can explicitly cast aux.size() to the type that you want. For example:

sqrt(double(aux.size()));

or

sqrt(float(aux.size()));

This makes the call unambiguously match one of the two functions. Depending on the precision you want, you can choose any of the three overloads. Since you're just casting back to an int, it's probably fine to cast to a float here.

---

aux.size() returns an std::size_t, but sqrt() does not have an overloaded version that takes a std::size_t argument.

The compiler reports that sqrt has 3 overloads: which take float, double and long double arguments. std::size_t could be converted to any of those, so there's an ambiguity since the compiler doesn't know whether to convert std::size_t to float or double or long double.

---

Try casting your aux.size() to one of those types, so it won't be ambiguous...