当 'operator <=>' 足够时，为什么我必须提供 'operator =='？

Question

#include <compare>

struct A
{
    int n;

    auto operator<=>(A const& other) const
    {
        if (n < other.n)
        {
            return std::strong_ordering::less;
        }
        else if (n > other.n)
        {
            return std::strong_ordering::greater;
        }
        else
        {
            return std::strong_ordering::equal;
        }
    }

    // compile error if the following code is commented out.
    // bool operator==(A const& other) const
    // { return n == other.n; }
};

int main()
{   
    A{} == A{};
}

见online demo

为什么我必须提供 operator == 何时 operator <=> 足够了？

Answer 1

operator<=> 足够了，为什么我必须提供operator==？

嗯，主要是因为它不够 :-)

在 C++ 重写您的语句时，平等和排序是不同的桶：

	Equality	Ordering
Primary	==	<=>
Secondary	!=	<, >, <=, >=

主算子可以取反，辅算子可以根据对应的主算子重写：

• 反转意味着a == b 可以是：
  • a.operator==(b) 如果有的话；或
  • b.operator==(a) 如果没有。
• 重写意味着a != b可以是：
  • ! a.operator==(b) 如果有的话

最后一个也可能是! b.operator==(a)，如果您必须重写并反转它（我不完全确定这一点，因为我的经验主要是与相同的类型进行比较）。

但默认情况下不跨越相等/排序边界进行重写的要求意味着<=> 不是== 的重写候选者。

---

在this P1185 paper 中可以找到平等和排序分开的原因，来自讨论此问题的众多标准会议之一。

在许多情况下，根据<=> 自动实现== 可能效率很低。想到字符串、向量、数组或任何其他集合。您可能不想使用<=> 来检查两个字符串的相等性：

• "xxxxx(a billion other x's)";和
• "xxxxx(a billion other x's)_and_a_bit_more".

这是因为<=> 必须处理整个 字符串来计算排序，然后检查排序是否强相等。

但预先进行简单的长度检查会非常快速告诉您它们是不相等的。这就是 O(n) 时间复杂度（十亿次左右的比较）与 O(1) 之间的差异，一个近乎立即的结果。

---

如果你知道它会没问题，你总是可以默认相等（或者你很乐意忍受它可能带来的任何性能损失）。但最好不要让编译器为您做出决定。

更详细地说，考虑以下完整的程序：

#include <iostream>
#include <compare>

class xyzzy {
public:
    xyzzy(int data) : n(data) { }

    auto operator<=>(xyzzy const &other) const {
        // Could probably just use: 'return n <=> other.n;'
        // but this is from the OPs actual code, so I didn't
        // want to change it too much (formatting only).

        if (n < other.n) return std::strong_ordering::less;
        if (n > other.n) return std::strong_ordering::greater;
        return std::strong_ordering::equal;
    }

    //auto operator==(xyzzy const &other) const {
    //    return n == other.n;
    //}

    //bool operator==(xyzzy const &) const = default;

private:
    int n;
};

int main() {
    xyzzy twisty(3);
    xyzzy passages(3);

    if (twisty < passages) std::cout << "less\n";
    if (twisty == passages) std::cout << "equal\n";
}

它不会按原样编译，因为它需要一个operator== 来作为最终语句。但是您不必提供 real 一个（第一个注释掉的块），您可以告诉它使用默认值（第二个）。而且，在这种情况下，这可能是正确的决定，因为使用默认值不会对性能产生真正的影响。

---

请记住，如果您显式提供三路比较运算符（当然您使用== 或!=），则只需要提供相等运算符。如果您都不提供，C++ 将为您提供两个默认值。

而且，即使您必须提供两个功能（其中一个可能是默认功能），它仍然比以前更好，您必须明确地提供它们全部，类似：

• a == b.
• a < b。
• a != b，定义为! (a == b)。
• a > b，定义为! (a < b || a == b)。
• a <= b，定义为a < b || a == b。
• a >= b，定义为! (a < b)。

Answer 2

当'operator '足够时，为什么我必须提供'operator =='？

因为它不会被使用。

如果你使用默认的就足够了：

struct A
{
    int n;
    auto operator<=>(A const& other) const = default;
};

---

基本上，n == n 可能比(a <=> a) == std::strong_ordering::equal 更有效，并且在很多情况下这是一种选择。当您提供用户定义的<=> 时，语言实现无法知道后者是否可以替换为前者，也无法知道后者是否不必要地低效。

因此，如果您需要自定义三路比较，则需要自定义相等比较。示例类不需要自定义的三路比较，所以你应该使用默认的。

Answer 3

查看前面的答案，没有人解决另一个问题：出于排序目的，两个对象可能相等但不相等。例如，我可能想对 Unicode NFC 规范化中的字符串进行排序，将大小写折叠为小写，但对于相等性测试，我想验证字符串实际上是否相同，大小写很重要，甚至可能区分 é 和 ´ + e 在输入中。

是的，这是一个有些人为的例子，但它表明<=> 的定义不需要strong 排序，因此您不能依赖<=>，甚至可能返回@ 987654326@。使== 默认为<=> 返回std::strong_ordering::equal 不能被认为是一个有效的实现。

Answer 4

因为== 的实现有时比使用a <=> b == 0 更快，所以编译器默认拒绝使用可能不是最佳的实现。

例如考虑std::string，它可以在遍历元素之前检查大小是否相同。

请注意，您不必手动实现==。你可以=default它，它将按照<=>来实现它。

另请注意，如果您是=default <=> 本身，则不需要=defaulting ==。

Answer 5

不，你没有。 只需添加

  bool operator==(A const& other) const = default;

https://godbolt.org/z/v1WGhxca6

您始终可以将它们重载为不同的语义。为了防止意外的自动生成函数，需要= default