C++20使用等号运算符是否会破坏现有代码的行为？

Question

C++20使用等号运算符是否会破坏现有代码的行为？

118

在调试这个问题时，我遇到了这个。

我将其简化到仅使用Boost Operators：

Compiler Explorer 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
}

This program compiles and runs fine with C++17 (ubsan/asan enabled) in both GCC and Clang.

When you change the implicit constructor to explicit, the problematic lines obviously no longer compile on C++17

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

显然，通过升级到C++20引入这种潜在错误是令人担忧的。

问题：

这是符合C++20的行为吗（我认为是）
究竟是什么干扰了？我怀疑可能是由于C++20的新“太空船运算符”支持，但不理解它如何改变此代码的行为。

- sehe

10

我认为这个问题是：boost::equality_comparable2 operator== 在使用clang10和-std=c++2a时可能会编译成无限循环。 - Shafik Yaghmour

4

你们真是太快了。这个世界不配得到这样水平的支持。谢谢你们。 - sehe

1

我不认为这是一个重复的问题，但它肯定与此相关 https://dev59.com/IFIG5IYBdhLWcg3wkBsx - cigien

1

@cigien 感激不尽。那里的答案解释非常出色，有助于形成更完整的理解。 - sehe

1个回答

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- Barry · Accepted Answer

事实上，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 reversed)。仍然选择#2 - 我们恰好匹配两个参数，而不是调用转换，因此被选中。

现在，x == y又有两个候选者了：再次是成员候选者(#1)，但也有了反转的非成员候选者(#2 reversed)。由于相同的原因，#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;
};