最近，我发现GCC改变了部分排序时的行为，具体情况如下：

#include <iostream>
template<class T>
struct unknow_context{
    using type = int;
};
template<class U>
void show(typename unknow_context<U>::type, U){ // candidate #1
    std::cout<<"#1\n";
}

template<class T>
void show(int, T){   // candidate #2
    std::cout<<"#2\n";
}
int main(){
    show(0,0);  
}

结果是，Clang打印#2（任何版本的Clang都打印了一致的结果）。但是，GCC有不同的行为。旧版本的GCC打印#2，相反，最新的GCC抱怨候选函数是模棱两可的。让我们看看标准对部分排序的规定。
temt. enpt.部分#2

推演过程使用转换后的类型作为参数模板，另一个模板的原始类型作为参数模板。这个过程对部分排序比较中涉及的每个类型做两次：一次使用转换后的模板-1作为参数模板，模板-2作为参数模板，再次使用转换后的模板-2作为参数模板，模板-1作为参数模板。

因此，我们可以分别为候选#1和#2得到两组P/A对。一个是转换后的#1为A，原始#2为P。另一个是原始#1为P，转换后的#2为A。所以这两个集合将如下给出：

#a  
|--------|------------------------------------------|
| P (#2) | A (#1)                                   |   
|--------|------------------------------------------|  
| int    |  typename unknow_context<UniqueA>::type  |
|--------|------------------------------------------|   
| T      | UniqueB                                  |   
|--------|------------------------------------------|  

T可以从UniqueB中推导出来。对于第一组，规则说：

如果特定的P不包含参与模板参数推导的模板参数，则该P不用于确定排序。

所以，我们先把它们放在一边，然后再考虑。

#b  
|----------------------------------|-------|
|P (#1)                            |A (#2) |   
|----------------------------------|-------|  
| typename unknow_context<U>::type |int    |  
|----------------------------------|-------|
| U                                |UniqueA|  
|----------------------------------|-------|

对于非推导上下文，其值可以从其他地方获得。

但是，在某些上下文中，该值不参与类型推导，而是使用在其他地方推导或显式指定的模板参数的值。如果模板参数仅在非推导上下文中使用并且未显式指定，则模板参数推导将失败。

因此，我们可以忽略对typenameunknow_context

如果给定类型的推导成功，则参数模板中的类型被认为至少与参数模板中的类型一样专业。

从#b，我们得到#2至少与#1一样专业的结果。

问题在#a set中。第二对没有问题，我们可以说#1的第二部分至少和#2的第二部分一样专业。

但是，函数模板F是否比函数模板G更专业的规则定义为：

如果对于用于确定排序的每一对类型，来自F的类型至少与来自G的类型一样专业，则函数模板F至少与函数模板G一样专业，如果F至少与G一样专业，并且G至少不像F一样专业，则F比G更专业。

因此，我们注意对int/typenameunknow_context

[注意：在[temp.deduct.call]和[temt.扣除.部分]下，如果P不包含出现在推导上下文中的模板参数，则不进行推导，因此P和A不需要具有相同的形式。

所以，到目前为止，从P/A集合#a来看，#1至少还是和#2一样专业（推演成功）。所以，我认为最新的GCC应该是正确的（模棱两可，两者都没有比另一个更专业）。

哪个编译器是正确的？

是否在部分排序时执行特化的实例化？标准似乎没有规定是否会执行实例化。

#include <iostream>
template<class T>
struct unknow_context{
    using type = T;
};
template<class U>
void show(typename unknow_context<U>::type, U){
    std::cout<<"#1\n";
}

template<class T>
void show(T, T){
    std::cout<<"#2\n";
}
int main(){
    show(0,0);
}

都选择了#2。我担心其中的特定P/A对，即：

|----|------------------------------------------------------------|
|P   |A                                                           |    
|----|------------------------------------------------------------|  
|T   |typename unknow_context<UniqueA>::type /*Is it equivalent to| 
|    | UniqueA? */                                                |  
|----|------------------------------------------------------------|   
|T   |UniqueA                                                     |  
|----|------------------------------------------------------------|  

typename是否unknow_context