事实上，不幸的是，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} .
在c17中，我们只有一个候选者：非成员候选者( #2 )，所以我们选择它。它的身体， x == y ，本身只有一个候选：成员候选( #1 )其中包括隐式转换 y 变成一个 F . 然后候选成员比较两个整数成员，这是完全正确的。
在c20中，初始表达式 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;
};