解决此模板分辨率歧义的正确方法是什么？

Question

假设我写了：

template <typename T, typename = std::enable_if_t<std::is_integral<T>::value>>
void foo() { std::cout << "T is integral." << std::endl; }

template <typename T>
void foo() { std::cout << "Any T." << std::endl; }

int main() { foo<short>(); }

当我编译这个时，我得到一个关于调用歧义的错误（如果我用float 替换short 则没有错误）。我应该如何修复此代码，以便获得整数类型的较高版本和较低版本？

如果您的建议适用于除通用版本之外的多个专用版本的foo()，则可获得奖励积分。

Answer 1

我喜欢Xeo's approach 解决这个问题。让我们做一些带有后备的标签调度。创建一个从自身向下继承的选择器结构：

template <int I>
struct choice : choice<I + 1> { };

template <> struct choice<10> { }; // just stop somewhere

所以choice<x> 可以转换为choice<y> 为x < y，这意味着choice<0> 是最好的选择。现在，您需要最后一个案例：

struct otherwise{ otherwise(...) { } };

有了这个机制，我们可以用一个额外的参数来转发我们的主函数模板：

template <class T> void foo() { foo_impl<T>(choice<0>{}); }

然后让你的 top 选择变得完整，你的最坏情况的选择......任何东西：

template <class T, class = std::enable_if_t<std::is_integral<T>::value>>
void foo_impl(choice<0> ) {
    std::cout << "T is integral." << std::endl;
}

template <typename T>
void foo_impl(otherwise ) {
    std::cout << "Any T." << std::endl;
}

这使得在中间添加更多选项变得非常容易。只需为choice<1> 或choice<2> 或其他任何内容添加重载。也不需要不相交的条件。 choice<x> 的优先重载解决方案可以解决这个问题。

如果你另外传入T 作为参数会更好，因为重载比专门化要好得多：

template <class T> struct tag {};
template <class T> void foo() { foo_impl(tag<T>{}, choice<0>{}); }

然后你就可以疯狂了：

// special 1st choice for just int
void foo_impl(tag<int>, choice<0> );

// backup 1st choice for any integral
template <class T, class = std::enable_if_t<std::is_integral<T>::value>>
void foo_impl(tag<T>, choice<0> );

// 2nd option for floats
template <class T, class = std::enable_if_t<std::is_floating_point<T>::value>>
void foo_impl(tag<T>, choice<1> );

// 3rd option for some other type trait
template <class T, class = std::enable_if_t<whatever<T>::value>>
void foo_impl(tag<T>, choice<2> );

// fallback 
template <class T>
void foo_impl(tag<T>, otherwise );

Answer 2

使用标签调度 (C++11) 的另一个选项：

#include <iostream>

void foo_impl(std::false_type) {
    std::cout << "Any T." << std::endl;
}

void foo_impl(std::true_type) {
    std::cout << "T is integral." << std::endl;
}

template <typename T>
void foo() {
    foo_impl(std::is_integral<typename std::remove_reference<T>::type>());
  //foo_impl(std::is_integral<typename std::remove_reference_t<T>>()); // C++14
}

int main() { 
    foo<short>();  // --> T is integral.
    foo<short&>(); // --> T is integral.
    foo<float>();  // --> Any T.
}

借自 Scott Meyers Effective Modern C++ item 27.

Answer 3

一种方式：

template <typename T, typename std::enable_if_t<std::is_integral<T>::value>* = nullptr>
void foo() { std::cout << "T is integral." << std::endl; }

template <typename T, typename std::enable_if_t<not std::is_integral<T>::value>* = nullptr>
void foo() { std::cout << "Any T." << std::endl; }

另一种方法是遵循模板函数对象：

template<class T, typename = void>
struct foo_impl
{
    void operator()() const {
        std::cout << "Any T." << std::endl;
    }
};

template<class T>
struct foo_impl<T, std::enable_if_t<std::is_integral<T>::value>>
{
    void operator()() const {
        std::cout << "T is integral." << std::endl;
    }
};

template<class T>
void foo() {
    return foo_impl<T>()();
}

Answer 4

一种方法是：

template <typename T>
std::enable_if_t<std::is_integral<T>::value, void> foo () {
    std::cout << "integral version" << std::endl;
}

template <typename T>
std::enable_if_t<!std::is_integral<T>::value, void> foo () {
    std::cout << "general version" << std::endl;
}

有用法：

foo<int> ();
foo<double> ();
struct X {};
foo<X> ();

输出是：

integral version
general version
general version

Answer 5

AFAIK，sfinae 适用于函数参数，所以尝试添加具有默认值的依赖类型的参数

template <typename T>
void foo(typename std::enable_if_t<std::is_integral<T>::value>* = 0) 
{ std::cout << "T is integral." << std::endl; }

template <typename T>
void foo(typename std::enable_if_t<!std::is_integral<T>::value>* = 0) 
{ std::cout << "Any T." << std::endl; }