Ambiguous call to abs

Question

I have a custom data type that in practice can be either float or double. On every OS except OSX, I am able to successfully build this C++11 template:

#include <cmath>
#include <cstdlib>
#include <cstdint>

template< class REAL_T >
inline REAL_T inhouse_abs(REAL_T i_val)
{
    return std::abs((REAL_T)i_val);
}

int main()
{
    int32_t ui = 2;
    inhouse_abs(ui);
    return 0;
}

However, clang 6.0 (3.5 LLVM) reports an ambiguous function call. If I change abs to fabs, the error is resolved on OSX, but now an identical error shows up on my Linux clang, gcc, and Visual Studio.

Error on Visual Studio with fabs:

349 error C2668: 'fabs' : ambiguous call to overloaded function

UPDATE

This example compiled on our OS X systems, although in the nearly identical project it does not. The solution was including <cstdlib> explicitly in the source, rather than back in another header. The reason is unclear, but seems to be xcode/clang not following our header includes properly.

@Collin Added the Visual Studio error. Will need a minute to find the clang analog. — EntangledLoops, May 06 '15 at 18:22
@ShafikYaghmour The error is generated at that line without any calls necessary. — EntangledLoops, May 06 '15 at 18:23
Your fully example make more sense now. Updated my original answer. — Shafik Yaghmour, May 06 '15 at 20:38

score 12 · Accepted Answer · edited May 23 '17 at 11:54

The issue is that libc++ is not entirely C++11 compliant with the integral overload for std::abs in cmath:

double      fabs( Integral arg ); (7)   (since C++11)

Including cstdlib solves your problem since that header has overloads specifically for integer types.

For reference the draft C++11 standard section 26.8 [c.math] paragraph 11 says:

Moreover, there shall be additional overloads sufficient to ensure:

and includes the following item:

Otherwise, if any argument corresponding to a double parameter has type double or an integer type, then all arguments corresponding to double parameters are effectively cast to double.

This is situation very likely to change due to LWG active issue 2192: Validity and return type of std::abs(0u) is unclear. I am guessing libc++ choose not to provide the overloads in cmath due to the issue brought up in this defect report.

See Is std::abs(0u) ill-formed? for more details on this.

score 4 · Answer 2 · answered May 06 '15 at 19:33

4

The solution was to explicitly #include <cstdlib> on the OS X machine, as for some reason Visual Studio finds it in our dependencies and includes it, but clang does not. I will try to reproduce a similar chain of includes that our project has and reproduce the error in a minimalist way, as it may still be a problem either with Xcode or Visual Studio.

answered May 06 '15 at 19:33

EntangledLoops

1,951
1
23
36

Helped me in my project written in Xcode, too. Thanks! – Fengson Dec 30 '15 at 08:07
Glad I saved somebody else some time! – EntangledLoops Dec 30 '15 at 16:19

score 1 · Answer 3 · answered Aug 01 '18 at 17:10

If you have many template functions causing this problem, you can use the following drop-in replacement:

#include <cmath>
#include <cstdlib>
#include <type_traits>

namespace util {


template <class T>
auto abs(T value) -> std::enable_if_t<std::is_unsigned<T>::value,
                                      T> { return value; }
template <class T>
auto abs(T value) -> std::enable_if_t<std::is_floating_point<T>::value,
                                      T> { return std::fabs(value); }
template <class T>
auto abs(T value) -> std::enable_if_t<std::is_same<T, int>::value,
                                      T> { return std::abs(value); }
template <class T>
auto abs(T value) -> std::enable_if_t<std::is_same<T, long>::value,
                                      T> { return std::labs(value); }
template <class T>
auto abs(T value) -> std::enable_if_t<std::is_same<T, long long>::value,
                                      T> { return std::llabs(value); }
template <class T>
auto abs(T value) -> std::enable_if_t<std::is_signed<T>::value &&
                                          !std::is_floating_point<T>::value &&
                                          !std::is_same<T, int>::value &&
                                          !std::is_same<T, long>::value &&
                                          !std::is_same<T, long long>::value,
                                      T> { return std::abs(value); }


} // namespace util

Just replace the std::abs calls with util::abs. (Needs c++11.)

Ambiguous call to abs

3 Answers3

Linked