带有 enable_if 的部分模板函数特化：默认实现

Question

使用 C++11 的 enable_if 我想为一个函数定义几个专门的实现（例如，基于参数的类型）以及一个默认实现。正确的定义方式是什么？

以下示例无法按预期工作，因为调用了“通用”实现，无论T 是什么类型。

#include <iostream>

template<typename T, typename Enable = void>
void dummy(T t)
{
  std::cout << "Generic: " << t << std::endl;
}


template<typename T, typename std::enable_if<std::is_integral<T>::value>::type>
void dummy(T t)
{
  std::cout << "Integral: " << t << std::endl;
}


template<typename T, typename std::enable_if<std::is_floating_point<T>::value>::type>
void dummy(T t)
{
  std::cout << "Floating point: " << t << std::endl;
}

int main() {
  dummy(5); // Print "Generic: 5"
  dummy(5.); // Print "Generic: 5"
}

在我的最小示例中，一个解决方案是明确声明“通用”实现不适用于整数或浮点类型，使用

std::enable_if<!std::is_integral<T>::value && !std::is_floating_point<T>::value>::type

这正是我想要避免的，因为在我的实际用例中有很多专门的实现，我想避免默认实现的时间很长（容易出错！）。

Answer 1

您可以引入rank 来优先处理您的一些重载：

template <unsigned int N>
struct rank : rank<N - 1> { };

template <>
struct rank<0> { };

然后您可以像这样定义 dummy 重载：

template<typename T>
void dummy(T t, rank<0>)
{
    std::cout << "Generic: " << t << std::endl;
}

template<typename T, 
         typename std::enable_if<std::is_integral<T>::value>::type* = nullptr>
void dummy(T t, rank<1>)
{
    std::cout << "Integral: " << t << std::endl;
}

template<typename T, 
         typename std::enable_if<std::is_floating_point<T>::value>::type* = nullptr>
void dummy(T t, rank<1>)
{
    std::cout << "Floating point: " << t << std::endl;
}

然后，您可以将呼叫隐藏在dispatch 后面：

template <typename T>
void dispatch(T t)
{
   return dummy(t, rank<1>{});
}

用法：

int main() 
{
    dispatch(5);    // Print "Integral: 5"
    dispatch(5.);   // Print "Floating point: 5"
    dispatch("hi"); // Print "Generic: hi"
}

live example on wandbox

---

说明：

使用rank 引入了“优先级”，因为当X > Y 时，需要隐式转换才能将rank<X> 转换为rank<Y>。 dispatch 首先尝试用rank<1> 调用dummy，优先考虑您的约束重载。如果enable_if 失败，rank<1> 会隐式转换为rank<0> 并进入“回退”情况。

---

奖励：这是一个使用 if constexpr(...) 的 C++17 实现。

template<typename T>
void dummy(T t)
{
    if constexpr(std::is_integral_v<T>)
    {
        std::cout << "Integral: " << t << std::endl;
    }
    else if constexpr(std::is_floating_point_v<T>)
    {
        std::cout << "Floating point: " << t << std::endl;
    }
    else
    {
        std::cout << "Generic: " << t << std::endl;
    }
}

live example on wandbox

Answer 2

函数不能部分特化。我假设您想要做的是更喜欢那些包含显式条件的重载？实现此目的的一种方法是在 default 函数的声明中使用可变参数省略号，因为省略号函数在重载解决顺序中的优先级较低：

#include <iostream>

template<typename T>
void dummy_impl(T t, ...)
{
  std::cout << "Generic: " << t << std::endl;
}


template<typename T, typename std::enable_if<std::is_integral<T>::value>::type* = nullptr>
void dummy_impl(T t, int)
{
  std::cout << "Integral: " << t << std::endl;
}


template<typename T, typename std::enable_if<std::is_floating_point<T>::value>::type* = nullptr>
void dummy_impl(T t, int)
{
  std::cout << "Floating point: " << t << std::endl;
}

template <class T>
void dummy(T t) {
   dummy_impl(t, int{});
}

int main() {
  dummy(5); 
  dummy(5.); 
  dummy("abc"); 
}

输出：

Integral: 5
Floating point: 5
Generic: abc

[live demo]

@doublep 在评论中提到的另一个选项是使用结构来实现您的功能，然后对其进行部分专门化。

Answer 3

我会像这样使用标签调度：

namespace Details
{
    namespace SupportedTypes
    {
        struct Integral {};
        struct FloatingPoint {};
        struct Generic {};
    };


    template <typename T, typename = void>
    struct GetSupportedType
    {
        typedef SupportedTypes::Generic Type;
    };

    template <typename T>
    struct GetSupportedType< T, typename std::enable_if< std::is_integral< T >::value >::type >
    {
        typedef SupportedTypes::Integral Type;
    };

    template <typename T>
    struct GetSupportedType< T, typename std::enable_if< std::is_floating_point< T >::value >::type >
    {
        typedef SupportedTypes::FloatingPoint Type;
    };

    template <typename T>
    void dummy(T t, SupportedTypes::Generic)
    {
        std::cout << "Generic: " << t << std::endl;
    }

    template <typename T>
    void dummy(T t, SupportedTypes::Integral)
    {
        std::cout << "Integral: " << t << std::endl;
    }

    template <typename T>
    void dummy(T t, SupportedTypes::FloatingPoint)
    {
        std::cout << "Floating point: " << t << std::endl;
    }
} // namespace Details

然后像这样隐藏样板代码：

template <typename T>
void dummy(T t)
{
    typedef typename Details::GetSupportedType< T >::Type SupportedType;
    Details::dummy(t, SupportedType());
}

GetSupportedType 为您提供了一种猜测您将要使用的实际类型的中心方法，即您每次添加新类型时要专门化的类型。

然后您只需通过提供正确的标签实例来调用正确的dummy 重载。

最后，调用dummy：

dummy(5); // Print "Generic: 5"
dummy(5.); // Print "Floating point: 5"
dummy("lol"); // Print "Generic: lol"