C++20三路比较符operator通过一次定义自动生成所有关系运算符，减少重复代码并提升一致性。它返回strong_ordering、weak_ordering或partial_ordering之一，分别表示强序、弱序和偏序关系，影响等价性和容器行为。使用=default可自动生成按成员声明顺序的字典序比较，但需注意成员顺序、访问权限及性能影响。手动实现适用于复杂逻辑。该特性简化了比较操作，增强了类型安全与代码可维护性。
C++20引入的三路比较符（
operator
），通常被称为“飞船操作符”，它的核心价值在于彻底简化了自定义类型所有关系比较操作的实现。过去，我们为一个类要实现等于、不等于、小于、小于等于、大于、大于等于这六个操作符，工作量大且极易出错，导致逻辑不一致。现在，通过定义一个
operator
，编译器就能自动推导出其他所有比较操作，大大减少了模板代码，提升了代码的健壮性和一致性。
解决方案
C++的三路比较符
operator
的设计理念是，通过一次比较操作返回一个表示左右操作数之间关系的枚举类型值。这个值可以是小于、等于或大于。根据返回的比较类别（
std::strong_ordering
,
std::weak_ordering
,
std::partial_ordering
），编译器能够自动生成所有其他的关系运算符。
具体来说，当你为一个类定义了
operator
，例如：
#include // 包含比较类别头文件#include #include class MyPoint {public: int x; int y; // 默认生成三路比较符，它会按成员声明顺序进行字典序比较 // 如果没有特殊需求，这是最简洁的方式 auto operator(const MyPoint&) const = default; // operator== 也可以默认生成，如果已默认，则通常不需要显式写出 // auto operator==(const MyPoint&) const = default; };// 假设我们有一个更复杂的类，需要自定义比较逻辑class Person {public: std::string name; int age; // 假设我们希望先按年龄比较，年龄相同再按名字比较 // 并且我们认为同名同龄的人是强等价的 std::strong_ordering operator(const Person& other) const { if (auto cmp = age other.age; cmp != 0) { return cmp; } return name other.name; // 字符串的会返回strong_ordering } // 默认生成operator==，因为我们已经提供了，编译器可以推导 // 也可以显式default // auto operator==(const Person& other) const = default;};int main() { MyPoint p1{1, 2}; MyPoint p2{1, 3}; MyPoint p3{1, 2}; std::cout << "p1 < p2: " << (p1 < p2) << std::endl; // 编译器自动生成 std::cout << "p1 == p3: " << (p1 == p3) << std::endl; // 编译器自动生成 std::cout < p3: " < p3) << std::endl; // 编译器自动生成 Person alice1{"Alice", 30}; Person alice2{"Alice", 25}; Person bob{"Bob", 30}; std::cout << "alice1 < alice2: " << (alice1 < alice2) << std::endl; // false (30 not < 25) std::cout < alice2: " < alice2) < 25) std::cout << "alice1 == bob: " << (alice1 == bob) << std::endl; // false (name different) std::cout << "alice1 < bob: " << (alice1 < bob) << std::endl; // true (Alice < Bob when age same) return 0;}
当你定义了
operator
，编译器会根据其返回的比较类别，自动为你提供
<, , >=
等操作符。对于
==
和
!=
，如果你没有显式定义
operator==
，并且定义了
operator
或将其
default
化，编译器也会自动为你生成
operator==
。这简直是魔法，一下子解决了多少年来的痛点。
立即学习“C++免费学习笔记（深入）”；
C++20三路比较符：告别重复，提升代码一致性？
在我看来，C++20引入三路比较符，与其说是“简化”，不如说是“修正”了长期以来类设计中一个不那么优雅的地方。过去，为一个自定义类型实现所有六个关系操作符，简直是重复劳动的典范。你总得写
operator<
，然后用它去实现
operator>
、
operator<=
等，或者干脆一个一个手写。这不仅代码量大，更容易在不同操作符之间引入细微的逻辑不一致，比如
operator<
和
operator==
的实现逻辑没有完美同步，导致一些令人头疼的bug。
有了
operator
，特别是结合
default
关键字，这种重复性工作被彻底消灭了。对于那些成员之间存在自然顺序的简单数据结构，一行
auto operator(const MyClass&) const = default;
就能搞定所有比较操作，这无疑是巨大的生产力提升。它强制我们思考的不再是“如何实现每一个比较符”，而是“我的类应该如何被比较”，这是一种更高层次的抽象。它把我们从繁琐的语法细节中解放出来，让我们能更专注于核心的业务逻辑，同时大大降低了潜在的错误风险。这种一致性的提升，远比单纯的“代码行数减少”更有价值。
三路比较符的返回类型选择：Strong, Weak, Partial Ordering如何区分？
三路比较符的返回类型是其核心概念之一，它们定义了比较结果的“强度”或“完整性”。理解
std::strong_ordering
、
std::weak_ordering
和
std::partial_ordering
的区别至关重要，因为它们决定了你的类型在不同上下文中的行为，比如在
std::map
或
std::set
中。
std::strong_ordering
(强序)： 这是最严格、最常见的比较类别。它意味着如果两个值比较结果为“相等”（
a b == 0
），那么它们在所有可观察的方面都是等价的，并且可以互相替换而不会改变程序的行为。比如，整数、浮点数（不考虑NaN）、大多数结构体和类，如果它们的所有成员都参与了比较且是强序的，那么它们的比较结果通常就是强序。这意味着如果
a == b
，那么
f(a)
和
f(b)
应该总是产生相同的结果。
示例：
Point{1,2}
和
Point{1,2}
。它们是强等价的。
std::weak_ordering
(弱序)： 弱序表示如果两个值比较结果为“相等”，它们在排序上是等价的，但它们可能在其他方面有所不同，不能完全互相替换。最典型的例子是大小写不敏感的字符串比较。
"Apple"
和
"Apple"
在弱序比较下可能是等价的，但它们在二进制表示上是不同的。这意味着
a == b
并不意味着
a
和
b
是完全相同的实体。
示例： 一个
User
类，你可能只比较
userId
，而
userName
和
即使不同也认为它们是等价的（如果
userId
相同）。或者一个
CaseInsensitiveString
类。
std::partial_ordering
(偏序)： 偏序是最不严格的类别，它允许某些值之间无法进行比较（unorderable）。浮点数的
NaN
(Not a Number) 是偏序的经典案例。
NaN
既不小于、不大于、也不等于任何数字（包括
NaN
自己）。当两个值无法比较时，偏序会返回
std::partial_ordering::unordered
。
示例： 包含浮点数的自定义类型。如果你的类成员可能包含
NaN
，并且
NaN
确实导致了无法排序的情况，那么就应该使用偏序。
如何选择？ 经验法则是：从
strong_ordering
开始考虑。如果你的类型所有等价的值在所有方面都完全相同且可互换，那就用
strong_ordering
。如果等价的值可能在某些不影响排序的方面有所不同（如大小写），则考虑
weak_ordering
。如果你的类型可能存在无法相互比较的值（如
NaN
），那么
partial_ordering
是你的选择。选择正确的比较类别，不仅影响了语义，也影响了容器和算法的行为，例如
std::set
会根据等价性来判断元素是否重复。
使用default关键字实现三路比较符：便捷性与注意事项
default
关键字在 C++20 中与三路比较符结合，简直是锦上添花，将代码简化到了极致。当你为一个类成员都支持
operator
的类使用
auto operator(const MyClass&) const = default;
时，编译器会为你自动生成一个
operator
的实现。这个默认实现会按照成员在类中声明的顺序，进行字典序（lexicographical）比较。
这意味着，如果你的类有成员
member1
,
member2
,
member3
，那么默认的
operator
会先比较
member1
。如果
member1
相同，再比较
member2
，以此类推。这种行为对于许多简单的值类型来说是完美的，因为它符合直觉，并且极大地减少了样板代码。更棒的是，如果你
default
了
operator
，并且没有显式定义
operator==
，编译器还会自动为你生成一个
operator==
，它会基于
operator
的结果来判断相等性。
然而，这种便捷性也带来了一些需要注意的地方：
成员声明顺序至关重要： 默认的字典序比较是严格按照成员声明顺序进行的。如果你希望某个成员的比较优先级更高，它就必须在类中声明得更靠前。例如，如果你有一个
Employee
类，想先按部门排序，再按姓名排序，那么
department
成员必须在
name
成员之前声明。如果顺序错了，你可能得到一个不符合预期的排序结果。私有成员的默认比较： 默认的三路比较符只能访问其能访问到的成员。如果你的私有成员没有提供公共的
operator
或
operator==
，或者它们是复杂类型，可能无法被默认比较。通常，如果所有成员都支持比较，且其访问权限允许，默认生成是可行的。非成员的比较逻辑： 如果你的比较逻辑依赖于类的非成员数据、全局状态，或者需要复杂的算法，那么
default
就不适用了。你必须手动实现
operator
，就像上面
Person
类的例子那样。性能考量： 对于拥有大量成员的类，默认的字典序比较可能会导致性能问题，因为它会逐个成员进行比较直到找到差异或所有成员都相同。在性能敏感的场景下，你可能需要手动实现一个更优化的比较逻辑。混合比较类别： 如果你的类成员包含不同比较类别的类型（例如，一个
strong_ordering
的
int
和一个
weak_ordering
的
std::string
），默认生成的
operator
会尝试提升到最弱的共同类别。这通常是安全的，但理解其行为很重要。
总而言之，
default
关键字是 C++20 赋予我们的强大工具，它让比较操作的实现变得前所未有的简单。但作为开发者，我们仍需保持警惕，确保默认行为符合我们的语义意图，并在必要时，毫不犹豫地卷起袖子，编写自定义的比较逻辑。
以上就是C++三路比较符 简化比较操作实现的详细内容，更多请关注创想鸟其它相关文章！
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 chuangxiangniao@163.com 举报，一经查实，本站将立刻删除。
发布者：程序猿，转转请注明出处：https://www.chuangxiangniao.com/p/1471990.html
微信扫一扫 
支付宝扫一扫 
