#include <iostream>
template<typename T>
struct A{};
struct Y{
    template<typename T>
    bool operator==(A<T>){
        std::cout<<"#1\n";
        return true;
    }
};
template<typename T>
bool operator==(T,Y){
    std::cout<<"#2\n";
    return true;
}
int main(){ 
    A<int> a;
    Y y;
    a==y;
}

对于上面的代码段，GCC打印#2，而Clang打印#1。结果在这里。我认为Clang是对的，因为#2是表达式a==y的非重写非成员候选。相反，#1的合成候选也是一个可行的函数。也就是说，重载集将由两个候选者组成，它们看起来像：

#1'
bool operator==(A<int>,Y); [with T = int] // synthesized candidate for #1

#2'
bool operator==(A<int>,Y);[with T = A<int>]

根据temp. func.order#3

如果通过重写的候选函数（[over. match.oper]）以相反的参数顺序通过重载解析来考虑其中一个函数模板，则转换后的模板中函数参数的顺序是相反的。

P/A对如下：

transformed type for #1: (A<uniqueT1>, Y) as A
original type for #2: (T, Y)  as P

transformed type for #2: (UniqueT2, Y) as A
original type for #1: (Y, A<UniqueT1>) as P

对于上述候选，模板函数的部分排序足以确定哪个是最佳可行的。哪个是子弹over.match.best#2.5

对于某些参数j，ICSj（F1）是比ICSj（F2）更好的转换序列，或者，如果不是这样，

2.5 F1和F2是函数模板特化，根据[temp. func.order]中描述的部分排序规则，F1的函数模板比F2的模板更特化，或者，如果不是这样，
[2.6-2.7]
2.8 F2是重写的候选（[over.match.oper]），而F1不是

这意味着没有必要进入第2.8项。根据上述P/A对，#1至少与#2一样专业，但#2至少不像#1那样专业；因此，#1'是部分排序的最佳可行候选者。所以，Clang在这里应该是正确的。

但是，请考虑以下变体片段

#include <iostream>
template<class T>
struct A{};

class Y{};

template<class T>
bool operator==(Y,A<T>){
    std::cout<<"#1\n";
    return true;
}

template<class T>
bool operator ==(T,Y){
    std::cout<<"#2\n";
    return true;
}

int main(){
   A<int> a;
   Y y{};
   a == y;
}

此时，Clang和GCC都同意#2是最佳可行候选者。结果在这里。然而，在我看来，这个例子与第一个相似。仅仅，它将成员候选者更改为非成员候选者。同样，重载集将由两个候选者组成，它们看起来像：

#1''
bool operator==(A<int>,Y); [with T = int]  // synthesized candidate for #1

#2''
bool operator==(A<int>,Y); [with T = A<int>]

在这个例子中，部分排序也足以确定哪个候选者是最好的。因此，#1"仍然应该是最好的。为什么Clang和GCC都认为#2在这个例子中是最好的？