Question

请考虑以下代码：

template <typename T>
struct dependent_type
{
    using type = T;
};

template <typename T>
auto foo(T) -> std::enable_if_t<std::is_same<T, int>{}>
{
    std::cout << "a\n"; 
}

template<typename T> 
void foo(typename dependent_type<T>::type) 
{
    std::cout << "b\n";
}

foo的第一次重载可以从其调用中推断出T。
foo的第二次重载是non-deduced context。

int main()
{    
    foo<int>( 1 );      // prints "b"
    foo<double>( 1.0 ); // prints "b"
    foo( 1 );           // prints "a"
}

为什么foo<int>( 1 )打印“b”而非“a”？

wandbox example

Answer 1

基本上，部分排序规则表明由于非推断的上下文，dependent_type重载更加专业化。

对模板函数进行排序的过程基于转换模板函数类型并依次对每个模板进行模板推导，一次从第一个模板（采用T的模板）到第二个模板（采用{{ {1}}），然后从第二个到第一个。

这些规则太复杂了，无法复制，但如果您想了解血腥细节，请阅读[temp.func.order]及其链接的段落。这是一个快速简化：

对于模板函数的每个模板参数，组成一个唯一类型并用该替换参数。此示例的转换类型为：

dependent_type

然后我们在两个方向上执行模板推导：一次使用第一个模板的参数作为第二个模板的参数，一次使用第二个参数作为第一个参数。这类似于对这些函数调用执行推论：

void foo(UniqueType); //ignoring the SFINAE for simplicity
void foo(typename dependent_type<UniqueType>::type);

在执行这些推论时，我们试图辨别一个重载是否比另一个更专业。当我们尝试第一个时，推导失败，因为//performed against template <class T> void foo(typename dependent_type<T>::type); foo(UniqueType{}); //performed against template <class T> void foo(T); foo(dependent_type<UniqueType>::type{});是一个非推导的上下文。对于第二个，扣除成功，因为typename dependent_type<T>::type只是dependent_type<UniqueType>::type，因此UniqueType推断为T。

由于演绎从第二个模板转到第一个模板失败，因此第二个模板比第一个模板更专业。最终结果是重载决策更喜欢UniqueType的第二个模板。

使用`std :: enable_if`和非推导的上下文重载函数模板消歧

1 个答案: