当“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{};
}

看在线演示

为什么我必须 operator == 在 足够的时候提供operator <=> ？

Answer 1

为什么我必须operator==在operator<=>足够的时候提供？

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

当 C++ 重写你的语句时，相等和排序是不同的：

	平等	订购
基本的	==	<=>
中学	!=	<、>、<=、>=

一级算子可以反转，二级算子可以根据对应的一级算子改写：

• 逆转意味着a == b可以是：
  • a.operator==(b)如果可供使用的话; 或者
  • b.operator==(a) 如果不。
• 重写意味着a != b可以是：
  • ! a.operator==(b) 如果可供使用的话

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

但要求是改写不会发生在默认情况下跨越平等/订货边界意味着<=>是不是一个重写的候选人==。

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

有许多场景中自动执行==来讲<=>可能是非常低效的。想到字符串、向量、数组或任何其他集合。您可能不想使用<=>来检查两个字符串的相等性：

• "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==用于最终语句。但是你不必提供一个真正的（第一个注释掉的块），你可以告诉它使用默认值（第二个）。而且，在这种情况下，这可能是正确的决定，因为使用默认值没有真正的性能影响。

请记住，如果您明确提供三向比较运算符（当然，并且您使用==或 ）!=，则只需要提供相等运算符。如果你都没有提供，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 在输入中。

是的，这是一个有点人为的例子，但它表明 的定义<=>不需要强排序，因此您<=>甚至不能依赖潜在的返回std::strong_ordering::equal。制作==默认为<=>收益std::strong_ordering::equal不能被认为是一个有效的执行。

Answer 4

因为==有时可以比 using 更快地实现a <=> b == 0，所以默认情况下编译器拒绝使用潜在的次优实现。

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

请注意，您不必==手动实施。你可以=default，这将在<=>.

还要注意，如果你=default <=>自己，那么=defaulting==是没有必要的。