enable_if 方法专门化

Question

template<typename T>
struct A
{
    A<T> operator%( const T& x);
};

template<typename T>
A<T> A<T>::operator%( const T& x ) { ... }

如何使用enable_if使任何浮点类型（is_floating_point）发生以下专门化？

template<>
A<float> A<float>::operator%( const float& x ) { ... }

编辑： 这是我提出的一个答案，它与下面发布的答案不同...

template<typename T>
struct A
{
    T x;

    A( const T& _x ) : x(_x) {}

    template<typename Q>
    typename std::enable_if<std::is_same<Q, T>::value && std::is_floating_point<Q>::value, A<T> >::type operator% ( const Q& right ) const
    {
        return A<T>(fmod(x, right));
    }

    template<typename Q>
    typename std::enable_if<std::is_convertible<Q, T>::value && !std::is_floating_point<Q>::value, A<T> >::type operator% ( const Q& right ) const
    {
        return A<T>(x%right);
    }
};

就像下面的海报所说，使用enable_if可能不适合这个问题（很难阅读）

Answer 1

当您想要优化更具体的参数类型的行为时，请使用重载而不是显式专业化。它更容易使用（更少的惊喜）和更强大

template<typename T>
struct A
{
    A<T> operator%( const T& x) { 
      return opModIml(x, std::is_floating_point<T>()); 
    }

    A<T> opModImpl(T const& x, std::false_type) { /* ... */ }
    A<T> opModImpl(T const& x, std::true_type) { /* ... */ }
};

一个使用 SFINAE (enable_if) 的例子，因为你似乎很好奇

template<typename T>
struct A
{
    A<T> operator%( const T& x) { 
      return opModIml(x); 
    }

    template<typename U, 
             typename = typename 
               std::enable_if<!std::is_floating_point<U>::value>::type>
    A<T> opModImpl(U const& x) { /* ... */ }

    template<typename U, 
             typename = typename 
               std::enable_if<std::is_floating_point<U>::value>::type>
    A<T> opModImpl(U const& x) { /* ... */ }
};

当然更难看。我认为没有理由在这里使用 enable_if 。这太过分了。

Answer 2

使用 C++20

只需添加 requires 来限制相关模板函数即可实现这一点：

template<typename Q> // the generic case, no restriction
A<T> operator% ( const Q& right ) const {
    return A<T>(std::fmod(x, right));
}

template<typename Q> requires std::is_integral_v<T> && std::is_integral_v<Q>
A<T> operator% ( const Q& right ) const {
    return A<T>(x % right);
}

requires子句获取一个常量表达式，其计算结果为true或false，从而决定是否在重载决策中考虑此方法（如果requires子句为true）该方法优于另一种没有 require 子句的方法，因为它更专业。

代码：https://godbolt.org/z/SkuvR9

Answer 3

您还可以使用默认布尔模板参数，如下所示：

template<typename T>
struct A
{
    T x;

    A( const T& _x ) : x(_x) {}

    template<bool EnableBool = true>
    typename std::enable_if<std::is_floating_point<T>::value && EnableBool, A<T> >::type 
    operator% ( const T& right ) const
    {
        return A<T>(fmod(x, right));
    }

    template<bool EnableBool = true>
    typename std::enable_if<!std::is_floating_point<T>::value && EnableBool, A<T> >::type 
    operator% ( const T& right ) const
    {
        return A<T>(x%right);
    }
};