C++20使用等式运算符破坏现有代码的行为？

Question

我在调试这个问题的时候碰到了这个。

我把它删减到只使用Boost运算符：

>

编译器资源管理器C++17 C++20

#include <boost/operators.hpp>

struct F : boost::totally_ordered1<F, boost::totally_ordered2<F, int>> {
    /*implicit*/ F(int t_) : t(t_) {}
    bool operator==(F const& o) const { return t == o.t; }
    bool operator< (F const& o) const { return t <  o.t; }
  private: int t;
};

int main() {
    #pragma GCC diagnostic ignored "-Wunused"
    F { 42 } == F{ 42 }; // OKAY
    42 == F{42};         // C++17 OK, C++20 infinite recursion
    F { 42 } == 42;      // C++17 OK, C++20 infinite recursion
}

这个程序可以在GCC和CLANG中用C++17（启用了UBSAN/ASAN）编译并运行良好。

当您将隐式构造函数更改为explicit时，有问题的行显然不再在C++17上编译

令人惊讶的是，这两个版本都在C++20(v1和v2)上编译，但它们导致了在C++17上无法编译的两行上的无限递归（崩溃或紧密循环，取决于优化级别）。

显然，这种通过升级到C++20而潜入的无声bug是令人担忧的。

问题：

• 此C++20行为是否符合（我希望如此）
• 到底什么是干扰？我怀疑这可能是由于C++20新的“宇宙飞船操作符”的支持，但不明白它是如何改变这段代码的行为的。

Answer 1

的确，C++20不幸地使这段代码无限递归。

下面是一个简化的示例：

struct F {
    /*implicit*/ F(int t_) : t(t_) {}

    // member: #1
    bool operator==(F const& o) const { return t == o.t; }

    // non-member: #2
    friend bool operator==(const int& y, const F& x) { return x == y; }

private:
    int t;
};

让我们看看42==F{42}。

在C++17中，我们只有一个候选者：非成员候选者(#2)，所以我们选择它。其主体x==y本身只有一个候选项：成员候选项(#1)，它涉及将y隐式转换为f。然后，成员候选比较两个整数成员，这是完全好的。

在C++20中，初始表达式42==F{42}现在有两个候选项：一个是以前的非成员候选项(#2)，另一个是反向成员候选项(#1反向）。#2是更好的匹配--我们精确匹配两个参数，而不是调用一个转换，因此选择了它。

但是，x==y现在有两个候选项：成员候选项(#1)，还有反向的非成员候选项(#2反向）。#2是更好的匹配，原因与之前的匹配相同：不需要转换。因此我们改为计算y==x。无限递归。

非反转的候选人优先于反转的候选人，但仅作为抢七者。更好的转换顺序总是第一。

好吧太好了，我们怎么解决它？最简单的选择是完全删除非成员候选人：

struct F {
    /*implicit*/ F(int t_) : t(t_) {}

    bool operator==(F const& o) const { return t == o.t; }

private:
    int t;
};

42==F{42}在这里的计算结果为F{42}。operator==(42)，可以正常工作。

如果我们想要保留非成员候选人，我们可以显式地添加它的反向候选人：

struct F {
    /*implicit*/ F(int t_) : t(t_) {}
    bool operator==(F const& o) const { return t == o.t; }
    bool operator==(int i) const { return t == i; }
    friend bool operator==(const int& y, const F& x) { return x == y; }

private:
    int t;
};

这使得42==F{42}仍然选择非成员候选者，但现在在正文中的x==y将选择成员候选者，这将执行正常的相等。

最后一个版本还可以删除非成员候选。以下方法也适用于所有测试用例，而不需要递归（这也是我接下来在C++20中编写比较的方法）：

struct F {
    /*implicit*/ F(int t_) : t(t_) {}
    bool operator==(F const& o) const { return t == o.t; }
    bool operator==(int i) const { return t == i; }

private:
    int t;
};