使用“std：：enable\u if”和非推断上下文消除重载函数模板歧义

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的第二个重载是一个非推断上下文。

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

为什么foo

wandbox示例




Answer 1

从本质上讲，部分排序规则说dependent_type重载由于该非推导上下文而更加专业化。

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

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

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

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{});

在执行这些推导时，我们试图辨别一个重载是否比另一个更专业。当我们尝试第一个时，推导失败，因为typenamedependent_type

由于从第二个模板到第一个模板的扣除失败，因此第二个模板被视为比第一个模板更专业化。最终的结果是重载解析更倾向于第二个模板