std :: abs用于“unsigned long long int”数据类型

Question

Why should I get this error

 C2668: 'abs' : ambiguous call to overloaded function

For a simple code like this

#include <iostream>
#include <cmath>
int main()
{
  unsigned long long int a = 10000000000000;
  unsigned long long int b = 20000000000000;
  std::cout << std::abs(a-b) << "\n";   // ERROR
  return 0;
}

The error still presents after removing std:: . However if I use int data type (with smaller values) there is no problem.

The traditional solution is to check that manually

std::cout << (a<b) ? (b-a) : (a-b) << "\n";

Is that the only solution?

Answer 1

The check seem the only really good solution. Alternatives require type bigger than yours and nonstandard extension to use it.

You can go with solutions casting to signed long long if your range fits. I would hardly suggest that way, especially if the implementation is placed in a function that does only that.

Answer 2

You are including <cmath> and thus using the " floating-point abs ".

The " integer abs " is declared in <cstdlib> .

However, there is no overload for unsigned long long int (both a and b are, thus ab is, too), and the overload for long long int only exists since C++11.

Answer 3

First, you need to include the correct header. As pointed out by gx_, <cmath> has a floating-point abs and on my compiler it actually compiles, but the result is probably not the one you expected:

1.84467e+19

Include <cstdlib> instead. Now the error is:

main.cpp:7:30: error: call of overloaded ‘abs(long long unsigned int)’ is ambiguous
main.cpp:7:30: note: candidates are:
/usr/include/stdlib.h:771:12: note: int abs(int)
/usr/include/c++/4.6/cstdlib:139:3: note: long int std::abs(long int)
/usr/include/c++/4.6/cstdlib:173:3: note: long long int __gnu_cxx::abs(long long int)

As you can see, there is no unsigned overload of this function, because computing an absolute value of something which is of type unsigned makes no sense.

I see answers suggesting you to cast an unsigned type to a signed one, but I believe this is dagereous , unless you really know what you are doing! Let me ask first what is the expected range of the values a and b that you are going to operate on? If both are below 2^63-1 I would strongly suggest to just use long long int . If that is not true however, let me note that your program for the values:

a=0, b=1

and

a=2^64-1, b=0

will produce exactly the same result , because you actually need 65 bits to represent any possible outcome of a difference of 2 64-bit values. If you can confirm that this is not going to be a problem, use the cast as suggested. However, if you don't know, you may need to rethink what you are actually trying to achieve.

Answer 4

Because back before C++ with C you used to have use abs, fabs, labs for each different type, c++ allows overloading of abs, in this case it doesn't understand or isn't happy with your overload.

Use labs(ab) seeing as you're using longs, this should solve your problem.