C++20重载模板相等运算符：GCC与MSVC/Clang行为差异谁正确？

问题场景 #

先看一段自定义可选类型的相等运算符实现代码：

#include <optional>

template <class T>
struct MyOptional{
    bool has_value() const { return false;}
    T const & operator*() const { return t; }
    T t{};
};

template <class T>
bool operator==(MyOptional<T> const & lhs, std::nullopt_t)
{
    return !lhs.has_value();
}

template <class U, class T>
bool operator==(U const & lhs, MyOptional<T> const & rhs)
{
    // gcc error: no match for 'operator==' (operand types are 'const std::nullopt_t' and 'const int')
    return rhs.has_value() ? lhs == *rhs : false;
}

int main(){
    MyOptional<int> o1;
    bool compiles = o1 == std::nullopt;
    bool doesNotCompile = std::nullopt == o1; // gcc fails
}

这段代码在Clang 15、MSVC 19.33下可正常编译，但GCC 12.2会触发如下错误：

<source>: In instantiation of 'bool operator==(const U&, const MyOptional<T>&) [with U = std::nullopt_t; T = int]':
<source>:26:43:   required from here
<source>:20:34: error: no match for 'operator==' (operand types are 'const std::nullopt_t' and 'const int')
   20 |     return rhs.has_value() ? lhs == *rhs : false;
      |                              ~~~~^~~~~~~
<source>:11:6: note: candidate: 'template<class T> bool operator==(const MyOptional<T>&, std::nullopt_t)' (reversed)
   11 | bool operator==(MyOptional<T> const & lhs, std::nullopt_t)
      |      ^~~~~~~~
<source>:11:6: note:   template argument deduction/substitution failed:
<source>:20:34: note:   mismatched types 'const MyOptional<T>' and 'const int'
   20 |     return rhs.has_value() ? lhs == *rhs : false;
      |                              ~~~~^~~~~~~
<source>:17:6: note: candidate: 'template<class U, class T> bool operator==(const U&, const MyOptional<T>&)' (reversed)
   17 | bool operator==(U const & lhs, MyOptional<T> const & rhs)
      |      ^~~~~~~~
<source>:17:6: note:   template argument deduction/substitution failed:
<source>:20:34: note:   'const std::nullopt_t' is not derived from 'const MyOptional<T>'
   20 |     return rhs.has_value() ? lhs == *rhs : false;
      |  

核心分歧 #

问题聚焦在std::nullopt == o1的重载解析逻辑：

• GCC认为第二个模板重载operator==(U const&, MyOptional<T> const&)是更优匹配，尝试实例化后，因函数体内std::nullopt == int无有效运算符而报错；
• Clang和MSVC则选择反转参数，调用已实现的operator==(MyOptional<T> const&, std::nullopt_t)完成比较。

针对C++20的相等比较自动参数反转机制，存在两种理解：

1. 编译器优先查找原参数顺序的有效匹配，找到则直接使用，不考虑反转；
2. 编译器同时纳入原参数顺序和反转参数顺序的所有可行函数，再从中选择最优匹配。

标准规定与结论 #

根据C++20标准的[over.match.oper]章节，对于==、!=这类相等性运算符，编译器会在重载候选函数生成阶段自动生成反转参数的候选函数，并将其加入候选集，之后统一执行完整的重载解析流程，而非单独优先处理原参数顺序的匹配。

回到本例：

• 原参数顺序的候选函数（第二个模板）虽可实例化，但函数体内存在无法解析的表达式，属于实例化错误；
• 反转参数后的候选函数（第一个模板）是完全匹配的可行函数，优先级不低于前者。

因此，Clang和MSVC的行为符合C++20标准，GCC的处理存在偏差——它错误地优先选择了原参数顺序的候选函数，未将反转后的候选函数纳入完整的重载解析比较。

参数反转的时机 #

参数反转发生在重载候选函数生成阶段：编译器会为每个相等性运算符表达式自动生成反转参数的候选函数，加入候选集。后续的模板推导、可行函数筛选、最佳函数选择等重载解析步骤，会统一处理所有候选函数，不存在原参数顺序优先的规则。

内容的提问来源于stack exchange，提问作者Sedenion