Ambiguous call to overloaded function 'pow'

Question

I\'m having some problems runnning the following code. I got this: error C2668: \'pow\' : ambiguous call to overloaded function. I\'ve tried to manually cast the arguments t

Answer 1

Though you marked your question as a C question you actually compile your program as a C++ program because it is C++ that allows to overload functions.

In your case the C++ compiler is unable to select an appropriate overloaded function pow. The error message clear shows what functions the compiler considers. To remove the ambiguity you could call the function for example the following way

result += (n[i] - 'a' + 10)* pow( 16.0, strlen(n) - i - 1.0 );

In this case the compiler would use function

double pow(double,double)

Take into account that in C/C++ function main shall have return type int.

In C the function is defined as

int main( void ) {

while in C++ it is usually defined as

int main() {

And I think there is a typo

    if (n[i] >= 'A')
        result += (n[i] - "A" + 10)* pow(16, strlen(n) - i - 1);

Instead of the string literal "A" there shall be character literal 'A'

Answer 2

In C language we can find library function under math.h:

double pow(double x, double y) ---- 1**

In C++ language we able to have set of overloaded functions under cmath such as:

float       pow( float base, float exp ) ---- 2
double      pow( double base, double exp ) ---- 3
long double pow( long double base, long double exp ) ---- 4
float       pow( float base, int iexp ) ---- 5
double      pow( double base, int iexp ) ---- 6
long double pow( long double base, int iexp ) ---- 7

Since you were using C style programming but compiled using C++ compiler,compiler might face with ambiguity states with defined function in math library,therefore you should convert your argument appropriately according to function definition 1 as mentioned above,therefore change your code as,

result += (n[i] - 'a' + 10)* pow(16.0, static_cast<double>(strlen(n) - i - 1))

ALSO NOTED with in your given code snippet there is a mistake as Perreal noted

if (n[i] >= 'A')
            result += (n[i] - "A" + 10)* pow(16, strlen(n) - i - 1);

you cannot do arithmetic operations with string literals.change it as Ptefan mentioned ,also change int result to double result if you need high precision and accurate results.

Answer 3

strlen return type is size_t in C++. So you can resolve the ambiguity via casting:

pow(static_cast<size_t>(16), strlen(n) - i - 1);

also here:

result += (n[i] - "A" + 10)

                  ^ this should be 'A'

and main should return int instead of void:

int main(void) { 

Answer 4

C++98 provides the following overloaded versions of pow:

     double pow (double base     , double exponent);
      float pow (float base      , float exponent);
long double pow (long double base, long double exponent);
     double pow (double base     , int exponent);
long double pow (long double base, int exponent);

The first argument you are using, 16, can be converted to any of the types of the first arguments used in those functions. Hence, the compiler cannot resolve the ambiguity. You can resolve the ambiguity by being explicit with the first argument, by specifying its type. Any one of the following should work:

pow(16.0, strlen(n) - i - 1);
pow(16.0f,  strlen(n) - i - 1);
pow(16.0l,  strlen(n) - i - 1);

If you are able to use C++11, you can use your existing code. It has an overload:

double pow (Type1 base      , Type2 exponent);

where Type1 and Type2 are arithmetic types.