三路比较运算符（）通过一个operator定义自动生成六个关系运算符。1. 它返回std::strong_ordering等类型表示比较结果；2. 编译器根据该结果推导出==、!=、、=；3. 使用default关键字可让编译器自动生成实现，适用于成员变量支持比较且需字典序的情况；4. 手动实现时需选择合适的返回类型（强序、弱序、偏序）以匹配业务逻辑；5. 注意=default的局限性、异构比较、成员可比较性、指针引用处理及继承体系中的行为。
C++20引入的三路比较运算符（，通常称为“飞船运算符”）极大地简化了自定义类型比较操作符的重载工作。它允许你通过定义一个成员函数来自动生成所有六个关系运算符（==, !=, , >, , >=），从而避免了大量重复且易错的代码。这不仅仅是代码量的减少，更是一种设计哲学上的进步，让比较逻辑变得更加集中和清晰。
解决方案
使用C++20的三路比较运算符来简化比较操作符重载的核心在于定义一个operator成员函数。这个运算符会返回一个表示两个对象之间排序关系的类型，如std::strong_ordering、std::weak_ordering或std::partial_ordering。编译器会根据这个单一的定义，自动推导出所有其他的关系运算符。
最简单的用法是利用default关键字，让编译器自动为你的类生成一个实现。这对于那些成员变量本身都支持三路比较，并且比较逻辑是简单的成员逐一比较（字典序）的类来说，简直是福音。
立即学习“C++免费学习笔记（深入）”；
#include // 包含 std::strong_ordering 等#include #include struct Point { int x; int y; // 使用 default 关键字让编译器自动生成三路比较运算符 // 它会按成员声明顺序（x, 然后y）进行逐一比较 auto operator(const Point&) const = default; // 注意：如果定义了 ，通常 operator== 也会被自动生成。 // 但为了清晰，或者当 equality 语义与 ordering 略有不同时，也可以显式 default operator==。 // bool operator==(const Point&) const = default; };struct Person { std::string name; int age; // 同样，default 适用于大部分情况 auto operator(const Person&) const = default;};int main() { Point p1{1, 2}; Point p2{1, 3}; Point p3{2, 2}; Point p4{1, 2}; std::cout << "p1 == p4: " << (p1 == p4 ? "true" : "false") << std::endl; // 自动生成 operator== std::cout << "p1 < p2: " << (p1 < p2 ? "true" : "false") << std::endl; // 自动生成 operator< std::cout < p3: " < p3 ? "true" : "false") < std::cout << "p1 <= p4: " << (p1 <= p4 ? "true" : "false") << std::endl; // 自动生成 operator<= Person alice{"Alice", 30}; Person bob{"Bob", 25}; Person charlie{"Alice", 30}; std::cout << "alice == charlie: " << (alice == charlie ? "true" : "false") << std::endl; std::cout << "alice < bob: " << (alice < bob ? "true" : "false") << std::endl; return 0;}
在这个例子中，我们只为Point和Person结构体定义了一个operator并标记为= default。编译器便会“魔法般”地生成所有我们需要的比较运算符。这对于我个人而言，简直是代码量和心智负担的双重解放。
三路比较运算符是如何简化传统六个比较操作符重载的？
在C++20之前，如果你想让一个自定义类型支持所有的比较操作，你通常需要重载至少三个运算符：operator==、operator!=（或者从==推导），以及operator。然后，operator>、operator、operator>=通常会基于operator和operator==来定义。这听起来可能不算太多，但当你的类成员很多，或者有继承关系时，编写和维护这六个（或至少三个核心）函数就变得非常繁琐且容易出错。我记得以前，每次写完这些，总要反复检查有没有写错哪个符号，或者逻辑是不是反了。
三路比较运算符的出现，彻底改变了这种局面。它返回一个枚举类型的值，表示左侧操作数与右侧操作数之间的关系：小于、等于、大于。这个单一的结果就足以推导出所有六种关系。
如果a b返回std::strong_ordering::less，那么a 为真。如果a b返回std::strong_ordering::equivalent（或equal），那么a == b为真。如果a b返回std::strong_ordering::greater，那么a > b为真。
编译器在看到operator的定义后，就能自动“合成”出==, !=, , >, , >=这些运算符。这意味着你只需要写一个函数，就能得到六个功能。这种自动化推导不仅减少了大量的样板代码，更重要的是，它消除了因手动实现这些运算符而引入的潜在不一致性错误。比如，你可能不小心让operator和operator>的逻辑相互冲突，或者operator==和operator!=没有正确地互补。的引入，从根本上解决了这类问题，因为它强制所有比较逻辑都从同一个“真相源头”派生。对我来说，这就像是给类型定义了一个单一的“比较规则”，然后让编译器去负责把这个规则应用到所有可能的比较场景中，省心不少。
选择合适的比较类别：strong_ordering, weak_ordering, partial_ordering
运算符的返回类型不是简单的布尔值，而是std::strong_ordering、std::weak_ordering或std::partial_ordering这三种之一。理解它们的区别至关重要，因为它决定了你的类型在不同场景下的比较行为。
std::strong_ordering (强序)
这是最严格的排序类型，也是我们最常遇到的。它表示一种“全序关系”，其中任何两个不相等的值都是可区分的，并且具有明确的先后顺序。特点： 如果a == b，那么a和b在语义上是完全相同的，并且它们可以互相替换而不会改变程序的行为。例如，整数、字符串（区分大小写）通常是强序的。何时使用： 当你的类型的所有可比较成员都支持强序，并且你希望“相等”意味着“完全相同”时，选择strong_ordering。defaulted 通常会推导出strong_ordering，除非有成员是弱序或偏序。
std::weak_ordering (弱序)
表示一种“全序关系”，但允许存在“等价”但不完全相同的值。特点： 如果a == b，那么a和b是等价的，但在某些方面它们可能仍然是可区分的。例如，进行大小写不敏感的字符串比较时，”Apple”和”apple”可能是等价的（==为真），但它们在内存中的表示是不同的。何时使用： 当你的类型具有一些不影响比较结果的“不重要”属性，或者在某些维度上允许“等价”而非“相同”时。比如，一个User类可能根据id进行比较，但last_login_time不同不影响其等价性。
std::partial_ordering (偏序)
这是最宽松的排序类型，它允许存在不可比较的值。特点： 除了小于、等于、大于之外，还存在第四种可能性：两个值是“无序”的。最典型的例子是浮点数中的NaN（Not-a-Number）。NaN与任何数（包括它自己）的比较结果都是无序的。何时使用： 当你的类型可能包含某些“无效”或“无意义”状态，导致无法与其他值进行有意义的比较时。例如，几何点可能在某些维度上缺失值，导致无法确定其相对于另一个点的精确顺序。
选择正确的返回类型至关重要。如果你defaulted ，编译器会根据你的成员类型自动选择最弱的那个。比如，如果你的类里有一个double成员，那么defaulted 很可能会返回partial_ordering。如果你手动实现，你需要根据你的业务逻辑来明确返回这三种类型之一。不恰当的选择可能会导致程序行为不符合预期，比如将本应无序的值进行了比较，或者错误地将等价的值视为完全相同。
#include #include #include #include // 举例偏序// 弱序示例：不区分大小写的字符串比较struct CaseInsensitiveString { std::string value; // 手动实现 返回 weak_ordering std::weak_ordering operator(const CaseInsensitiveString& other) const { // 这里需要一些实际的逻辑来做不区分大小写的比较 // 简化示例，实际可能需要转换成小写再比较 return value.compare(other.value) 0; // 这是一个简化的例子，实际需要更复杂的逻辑 } // 弱序通常需要明确定义 operator==，因为等价不意味着完全相同 bool operator==(const CaseInsensitiveString& other) const { // 假设这里实现不区分大小写的相等判断 return value.size() == other.value.size() && std::equal(value.begin(), value.end(), other.value.begin(), [](char a, char b){ return std::tolower(a) == std::tolower(b); }); }};// 偏序示例：可能为空的值（比如数据库中可为空的字段）struct NullableInt { std::optional value; // 手动实现 返回 partial_ordering std::partial_ordering operator(const NullableInt& other) const { if (!value.has_value() && !other.value.has_value()) { return std::partial_ordering::equivalent; // 两个都为空，视为等价 } if (!value.has_value()) { return std::partial_ordering::unordered; // 我为空，对方不为空，无法比较 } if (!other.value.has_value()) { return std::partial_ordering::unordered; // 对方为空，我方不为空，无法比较 } // 都有值时，进行强序比较 return value.value() other.value.value(); }};int main() { CaseInsensitiveString s1{"Apple"}; CaseInsensitiveString s2{"apple"}; CaseInsensitiveString s3{"Banana"}; std::cout << "s1 == s2: " << (s1 == s2 ? "true" : "false") << std::endl; // true (等价) std::cout << "s1 < s3: " << (s1 < s3 ? "true" : "false") << std::endl; // true NullableInt n1{10}; NullableInt n2{5}; NullableInt n3{}; // 空值 std::cout << "n1 < n2: " << (n1 < n2 ? "true" : "false") << std::endl; // false std::cout < n2: " < n2 ? "true" : "false") << std::endl; // true std::cout << "n1 == n3: " << (n1 == n3 ? "true" : "false") << std::endl; // false (无序) std::cout << "n1 < n3: " << (n1 < n3 ? "true" : "false") << std::endl; // false (无序) std::cout << "n3 == n3: " << (n3 == n3 ? "true" : "false") << std::endl; // true (等价) return 0;}
通过上面的例子，我们可以看到，根据实际的业务需求和数据特性，选择并实现正确的比较类别是至关重要的。这要求我们在设计类型时，就对它们的比较语义有清晰的认识。
在实际项目中应用三路比较运算符的注意事项和常见陷阱
尽管运算符极大地简化了比较操作符的重载，但在实际项目中应用它时，仍有一些需要注意的地方，避免踩坑。
= default的局限性：= default的运算符会按照成员声明的顺序进行逐一比较。这对于大多数简单的聚合类型是完美的。然而，如果你的比较逻辑不是简单的成员逐一比较（例如，你只想比较某些成员，或者比较逻辑涉及复杂的业务规则），那么= default就不够用了。这时你需要手动实现operator。在手动实现时，通常会用到std::tie或者std::compare_three_way来辅助，以确保逻辑的正确性和简洁性。
异构比较：也可以用于异构比较，即比较不同类型的对象。例如，一个Point类可以与一个int进行比较（假设int代表x坐标）。但这种情况下，你需要手动定义operator，并且返回类型要根据异构比较的语义来确定。这比同类型比较复杂一些，需要仔细考虑。
成员的可比较性：如果你的类中包含的成员类型不支持（例如，某些老旧的库类型，或者你自定义的没有定义比较运算符的类型），那么你defaulted 就会编译失败。遇到这种情况，你可能需要为这些成员类型添加支持，或者在你的类的中手动处理它们的比较逻辑。
指针和引用：当你的类成员是原始指针或引用时，defaulted 会比较它们的地址，而不是它们所指向或引用的值。这在大多数情况下不是你想要的。如果你希望比较指针或引用所指对象的值，你需要手动实现operator，并在其中解引用这些指针/引用进行比较。
继承体系中的比较：在继承体系中，defaulted 在派生类中会首先比较基类子对象，然后是派生类自己的成员。这通常是符合预期的行为。但如果你的基类没有定义，或者你希望派生类的比较逻辑完全覆盖基类的比较，就需要手动实现。
性能考量：对于拥有大量成员的非常大的类，defaulted 可能会导致编译器生成一个相对复杂的比较函数，它会逐一比较所有成员。在极度性能敏感的场景下，这可能不是最优解。你可能需要考虑手动实现一个更优化的，例如，提前退出比较（short-circuiting）或者只比较关键成员。不过，在绝大多数情况下，default的性能开销可以忽略不计。
与operator==的关系：如果你的类定义了operator，编译器会自动为你生成operator==。这意味着你通常不需要再显式地default或实现operator==。但如果你的相等性语义与排序语义有所不同（例如，弱序的情况），或者出于某些特殊原因，你仍然可以显式地定义或default operator==。显式定义的operator==会优先于从推导出的版本。
总的来说，是一个非常强大的工具，它大大提升了C++中自定义类型比较的便利性和安全性。但在使用时，理解其工作原理和潜在的限制，并根据具体需求选择= default还是手动实现，以及选择正确的返回类型，是确保代码健壮和高效的关键。
以上就是C++20的三路比较运算符怎么用 简化比较操作符重载的方法的详细内容，更多请关注创想鸟其它相关文章！
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 chuangxiangniao@163.com 举报，一经查实，本站将立刻删除。
发布者：程序猿，转转请注明出处：https://www.chuangxiangniao.com/p/1467678.html
微信扫一扫 
支付宝扫一扫 
