Ambigu appel à l'abs

J'ai un type de données personnalisé qui dans la pratique peut être float ou double. Sur tous les OS sauf OSX, je suis en mesure de réussir à construire ce C++11 modèle:

#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;
}

Cependant, clang 6.0 (3.5 LLVM) les rapports de l'ambiguïté d'un appel de fonction. Si je change abs à fabs, l'erreur est résolue sur OSX, mais maintenant à l'identique d'erreur s'affiche sur mon Linux clang, gcc, et Visual Studio.

Erreur sur Visual Studio avec fab:

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

Mise à JOUR

Cet exemple compilé sur nos systèmes OS X, bien que dans le près de identiques projet, il ne le fait pas. La solution a été notamment <cstdlib> explicitement dans la source, plutôt que dans un autre en-tête. La raison n'est pas claire, mais il semble être xcode/clang pas à la suite de notre en-tête comprend correctement.

Avez-vous l'erreur de texte?
Ajouté le Visual Studio erreur. Aurez besoin d'une minute pour trouver le cliquetis analogique.
L'erreur est généré à cette ligne sans appels nécessaires.
Donc, ce que les en-têtes sont vous, y compris etc....
Mis à jour avec exemple.

OriginalL'auteur EntangledLoops | 2015-05-06

  1. 8

    Le problème est que libc++ n'est pas entièrement en C++11 compatible avec l'intégrale de surcharge pour std::abs dans cmath:

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

    Y compris cstdlib résout votre problème depuis que la tête a surcharges spécifiquement pour les types integer.

    Pour référence le projet de C++11 section standard 26.8 [c.maths] paragraphe 11 dit:

    En outre, il doit y avoir d'autres surcharges suffisant pour assurer:

    et comprend les éléments suivants:

    1. Sinon, si un argument correspondant à un double paramètre est de type double ou un type entier, alors tous les arguments correspondant à
      double paramètres sont effectivement en fonte à double.

    Cette situation est très susceptible de changer en raison de LWG active problème 2192: la Validité et le type de retour de std::abs(0u) n'est pas claire. Je devine libc++ choisissez de ne pas fournir les surcharges dans cmath en raison de la question présenté dans ce rapport de défaut.

    Voir Est std::abs(0u) mal formé? pour plus de détails sur cette.

    OriginalL'auteur Shafik Yaghmour

  2. 3

    La solution a été explicitement #include <cstdlib> sur l'OS X de la machine, pour une raison quelconque Visual Studio trouve dans nos dépendances et il comprend, mais clang ne le fait pas. Je vais essayer de reproduire une semblable chaîne de comprend que notre projet a et reproduire l'erreur de manière minimaliste, qu'il peut encore être un problème avec Xcode ou Visual Studio.

    M'a aidé dans mon projet écrit dans Xcode, trop. Merci!
    Heureux que j'ai sauvé quelqu'un d'autre peu de temps!

    OriginalL'auteur EntangledLoops

  3. 0

    Si vous avez beaucoup de modèle de fonctions à l'origine de ce problème, vous pouvez utiliser le menu déroulant ci-dessous-en remplacement:

    #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

    Il suffit de remplacer le std::abs appels avec util::abs. (Besoins c++11.)

    OriginalL'auteur jan.sende