三路比较运算符怎么用简化比较操作符重载-C++-PHP中文网

三路比较运算符（operator<=>）通过定义单一比较逻辑，使编译器自动生成所有关系运算符，减少样板代码并提升一致性。只需实现operator<=>，即可推导出==、!=、<、<=、>、>=，避免手动实现带来的错误。返回类型如std::strong_ordering、std::weak_ordering和std::partial_ordering精确表达对象间序关系，适用于不同语义场景。对于简单类型，可使用= default让编译器自动生成；对于复杂逻辑，则手动实现，按优先级链式比较成员。该机制简化了代码维护，增强了类型比较的正确性和可读性，是C++20提升开发效率与代码质量的重要特性。

三路比较运算符怎么用简化比较操作符重载

三路比较运算符，也就是C++20引入的

operator<=>

登录后复制

（俗称“飞船操作符”），它的核心价值在于极大地简化了自定义类型的所有比较操作符（

==

登录后复制

!=

登录后复制

<=

登录后复制

>=

登录后复制

）的重载工作。你只需要实现一个

operator<=>

登录后复制

，编译器就能智能地帮你推导出其他所有关系运算符，从而显著减少样板代码，并提升代码的一致性和正确性。

解决方案

operator<=>

登录后复制

的作用，简单来说，就是一次性地判断两个对象之间是“小于”、“等于”还是“大于”的关系。它返回一个表示这种关系的特定类型对象（如

std::strong_ordering

登录后复制

）。一旦你为自定义类型实现了这个操作符，C++20的编译器就能自动地为你生成其他六个比较操作符（

==

登录后复制

!=

登录后复制

<=

登录后复制

>=

登录后复制

）的默认版本。这彻底改变了过去你需要为每个比较操作符单独编写重载函数的繁琐局面，不仅节省了大量编码时间，更重要的是，它从根本上消除了因手动实现不一致而导致的潜在逻辑错误。

具体来说，当你写下

auto operator<=>(const MyClass& other) const = default;

登录后复制

或者手动实现

operator<=>

登录后复制

时，编译器会利用这个单一的比较结果，自动推导出所有其他的比较关系。例如，如果

a <=> b

登录后复制

返回一个表示“小于”的结果，那么

a < b

登录后复制

自然为真，

a > b

登录后复制

为假，

a == b

登录后复制

也为假。这种机制极大地简化了类型作者的工作，也让代码更加健壮。

C++20 三路比较运算符：为何它能革新你的代码？

说实话，刚看到这玩意儿的时候，我心里是有点抗拒的，觉得又是一个C++搞出来的复杂新特性。但真正上手用起来，才发现它简直是C++程序员的福音啊！多少年了，我们为了一个自定义类型，不得不一遍又一遍地写着

operator<

登录后复制

、

operator==

登录后复制

，然后又用它们去实现

operator>

登录后复制

、

operator!=

登录后复制

等等。这过程不仅枯燥乏味，而且极其容易出错。比如，你可能在

operator<

登录后复制

里漏写了一个成员变量的比较，或者在

operator==

登录后复制

里写错了逻辑，这些细微的错误都可能导致整个程序的行为不符合预期，而且还特别难调试。

operator<=>

登录后复制

的出现，彻底解决了这个痛点。它提供了一个统一的入口来定义类型的“排序规则”。一旦这个规则确定了，其他所有的比较行为都是这个规则的自然推论。这不仅仅是减少了代码量那么简单，它更深层次的意义在于，它强制你以一种更结构化、更一致的方式去思考你的类型之间的“序”关系。你不再需要担心

a < b

登录后复制

和

b > a

登录后复制

的逻辑是否一致，因为它们都来源于同一个

operator<=>

登录后复制

的判断。这极大地提升了代码的正确性和可维护性，让开发者可以将精力集中在更核心的业务逻辑上，而不是陷在比较运算符的样板代码里。

深入理解

operator<=>

登录后复制

的返回值类型：

std::strong_ordering

登录后复制

、

std::weak_ordering

登录后复制

与

std::partial_ordering

登录后复制

operator<=>

登录后复制

的返回值并不是简单的布尔值，而是一个枚举类类型，它精确地描述了两个对象之间的比较结果。C++20定义了三种主要的序类型，每种都有其特定的语义和适用场景：

```
std::strong_ordering
```
登录后复制
: 这是最严格的序类型，表示“强全序”。当两个值被认为“相等”时，它们在所有可观察的方面都是等价的。比如，整数、浮点数（不考虑NaN）以及大多数结构体成员的比较结果，通常都属于强全序。这意味着，如果
```
a == b
```
登录后复制
，那么
```
a
```
登录后复制
和
```
b
```
登录后复制
在任何上下文下都可以互相替换，不会产生可观察的行为差异。它的成员包括
```
std::strong_ordering::less
```
登录后复制
,
```
std::strong_ordering::equal
```
登录后复制
,
```
std::strong_ordering::greater
```
登录后复制
。
```
std::weak_ordering
```
登录后复制
: 表示“弱全序”。在这种序下，两个值可能被认为是“相等”的，但它们在某些方面仍然可以区分。最典型的例子是字符串的不区分大小写比较。比如，"Hello"和"hello"在不区分大小写时是相等的，但它们在内存中存储的实际字节是不同的。这意味着它们虽然比较结果相等，但不能完全互换。它的成员与
```
strong_ordering
```
登录后复制
类似，但
```
equal
```
登录后复制
表示的是“等价”，而非“完全相同”。
```
std::partial_ordering
```
登录后复制
: 表示“偏序”。这是最宽松的序类型，意味着某些值之间可能无法比较。浮点数中的NaN（Not a Number）就是一个经典例子：
```
NaN
```
登录后复制
既不小于、不大于、也不等于任何数（包括它自己）。指针的比较也属于偏序，因为不同内存区域的指针可能无法进行有意义的比较。当两个值无法比较时，
```
partial_ordering
```
登录后复制
会返回
```
std::partial_ordering::unordered
```
登录后复制
。此外，它也有
```
less
```
登录后复制
,
```
equivalent
```
登录后复制
,
```
greater
```
登录后复制
。

理解这些返回类型至关重要，因为它决定了你的类型应该如何被比较。选择错误的序类型可能导致逻辑上的不一致。比如，如果你为包含NaN的浮点数类型错误地使用了

strong_ordering

登录后复制

，那么你的比较行为就可能出现意想不到的问题。通过

operator<=>

登录后复制

返回这些明确的序类型，我们能更准确地建模数据的比较特性，这在设计复杂系统时，无疑提供了强大的语义保证。

豆绘AI

豆绘AI是国内领先的AI绘图与设计平台，支持照片、设计、绘画的一键生成。

485

查看详情

如何为自定义类型实现

operator<=>

登录后复制

？自动生成与手动实现

实现

operator<=>

登录后复制

的方式主要有两种，这取决于你的类型结构和比较逻辑的复杂性。

1. 自动生成：

= default

登录后复制

对于结构相对简单、所有成员都支持比较操作的类型，C++20提供了最便捷的方式：使用

= default

登录后复制

。当你在类或结构体内部声明

operator<=>

登录后复制

并将其

= default

登录后复制

时，编译器会像处理默认构造函数或赋值运算符一样，自动为你生成一个“成员级”的比较逻辑。它会按照成员声明的顺序，依次对每个成员进行比较。如果某个成员的比较结果不为“相等”，则整个对象的比较结果就以此为准；否则，继续比较下一个成员，直到所有成员都比较完毕。

struct Point {
    int x;
    int y;
    // 编译器会依次比较x，然后比较y
    auto operator<=>(const Point&) const = default; 
};

// 示例用法
Point p1{1, 2};
Point p2{1, 3};
Point p3{1, 2};

// 编译器自动生成的其他比较操作符会生效
bool b1 = (p1 < p2);  // true, 因为p1.y < p2.y
bool b2 = (p1 == p3); // true, 因为p1.x == p3.x 且 p1.y == p3.y

登录后复制

这种方式对于大多数POD类型或只包含可比较成员的聚合类型来说，简直是神来之笔。它不仅代码量为零，而且保证了比较逻辑的正确性和一致性。

2. 手动实现

当你的类型比较逻辑比较复杂，或者你不想所有成员都参与比较，又或者你需要自定义比较顺序时，你就需要手动实现

operator<=>

登录后复制

。这通常涉及对成员进行逐个比较，并根据比较结果返回相应的序类型。

一个常见的模式是使用链式比较。你可以先比较最重要的成员，如果它们不相等，就返回它们的比较结果；如果相等，则继续比较下一个次要的成员，以此类推。

#include <compare> // For std::strong_ordering, etc.
#include <string>

struct Version {
    int major;
    int minor;
    int patch;

    // 手动实现三路比较运算符
    std::strong_ordering operator<=>(const Version& other) const {
        // 先比较major版本号
        if (auto cmp = major <=> other.major; cmp != 0) {
            return cmp; // 如果major不相等，直接返回结果
        }
        // major相等，再比较minor版本号
        if (auto cmp = minor <=> other.minor; cmp != 0) {
            return cmp; // 如果minor不相等，直接返回结果
        }
        // major和minor都相等，最后比较patch版本号
        return patch <=> other.patch; // 返回patch的比较结果
    }
};

// 示例用法
Version v1{1, 0, 5};
Version v2{1, 1, 0};
Version v3{1, 0, 5};

bool b1 = (v1 < v2);  // true
bool b2 = (v1 == v3); // true

登录后复制

手动实现提供了最大的灵活性。你甚至可以在其中加入自定义的业务逻辑，比如某些成员的比较权重更高，或者某些成员根本不参与比较。虽然需要编写代码，但相比于手动实现所有六个比较操作符，这依然是巨大的进步，因为它依然是定义“序”的唯一真理来源，其他操作符的推导依然是自动完成的。这要求开发者对