Operator ＜=＞ (spaceship operator)

operator <=>动机

在C++20以前定义比较运算符：其他比较运算符基于<和==实现

struct Type {int value;// 相等运算符friend bool operator==(const Type& a, const Type& b) {return a.value == b.value;}// 不等运算符friend bool operator!=(const Type& a, const Type& b) {return !(a == b);}// 小于运算符friend bool operator<(const Type& a, const Type& b) {return a.value < b.value;}// 其他比较运算符基于<和==实现friend bool operator>(const Type& a, const Type& b) {return b < a; // 通过交换参数重用operator<}friend bool operator<=(const Type& a, const Type& b) {return !(b < a); // a <= b 等价于 !(b < a)}friend bool operator>=(const Type& a, const Type& b) {return !(a < b); // a >= b 等价于 !(a < b)}
};

问题是，尽管大多数操作符都是根据其他操作符定义的(都基于operator == 或operator <)，但
这些定义很繁琐，而且会增加很多阅读上的混乱。
此外，对于实现良好的类型，可能需要更多的声明:
• 若操作符不能抛出，就用noexcept 声明
• 若操作符可以在编译时使用，则使用constexpr 声明
• 若构造函数不是显式的，则将操作符声明为“隐藏友元”(在类结构中与友元一起声明，以便
两个操作数都成为参数，并支持隐式类型转换)
• 声明带有[[nodiscard]] 的操作符，以便在返回值未使用时强制发出警告

struct Type {int value;// 隐式构造函数（根据需求决定是否explicit）Type(int v) noexcept : value(v) {}// 核心比较运算符（隐藏友元 + [[nodiscard]] + noexcept + constexpr）[[nodiscard]] friend constexpr bool operator==(const Type& a, const Type& b) noexcept {return a.value == b.value;}[[nodiscard]] friend constexpr bool operator<(const Type& a, const Type& b) noexcept {return a.value < b.value;}// 以下运算符通过核心运算符复用（隐藏友元 + 属性传递）[[nodiscard]] friend constexpr bool operator!=(const Type& a, const Type& b) noexcept {return !(a == b);}[[nodiscard]] friend constexpr bool operator>(const Type& a, const Type& b) noexcept {return b < a;}[[nodiscard]] friend constexpr bool operator<=(const Type& a, const Type& b) noexcept {return !(b < a);}[[nodiscard]] friend constexpr bool operator>=(const Type& a, const Type& b) noexcept {return !(a < b);}
};

C++20 后如何定义比较运算符。

== 与!= 操作符

为了检查是否相等，现在定义== 操作符就够了。
当编译器找不到表达式的匹配声明a!=b 时，编译器会重写表达式并查找!(a==b)。若这不起作
用，编译器也会尝试改变操作数的顺序，所以也会尝试!(b==a):

 operator <=>

The effect is that both operators use their default implementation, which compares objects member by member.

Notes that member function must be const and that the parameter must be declared to be a const lvalue reference (const &).

 Friend functions might alternatively take both parameters by value.

The return type of operator<=> is not an integral value. The return type is a type that signals the comparison category, which could be strong ordering, weak ordering, or partial ordering. These types support the comparison with 0 to deal with the result.

In addition, even when declaring the operator as a member function, the following applies for the generated operators:

• They are noexcept if comparing the members never throws

• They are constexpr if comparing the members is possible at compile time

• Thanks to rewriting, implicit type conversions for the first operand are also supported.

This reflects that, in general, operator== and operator<=> handle different but related things:

• operator== defines equality and can be used by the equality operators == and !=.

• operator<=> defines the ordering and can be used by the relational operators <, <=, >, and >=.

 TSL中已经删除了6中比较运算符

 

#include <iostream>struct Type
{auto operator <=> (const Type&) const = default;long id{};
};int main(void)
{Type a{10};Type b{20};auto ret = a == b;std::cout << std::boolalpha << ret << std::endl;return 0;
}

创建一个不区分大小写的字符串类型 CIString 的示例，该类型既可以与自身比较，也可以与 const char* 进行比较：

In C++17, this requires 18 comparison functions:

class CIString {std::string s;public:friend bool operator==(const CIString& a, const CIString& b) { ...}friend bool operator!=(const CIString& a, const CIString& b) { ... }friend bool operator> (const CIString& a, const CIString& b) { ... }friend bool operator>=(const CIString& a, const CIString& b) { ... }friend bool operator<(const CIString& a, const CIString& b) { ... }friend bool operator<=(const CIString& a, const CIString& b) { ... }friend bool operator==(const CIString& a, const char* b) { ... }friend bool operator< (const CIString& a, const char* b) { ... }friend bool operator!=(const CIString& a, const char* b) { ... }friend bool operator> (const CIString& a, const char* b) { ... }friend bool operator>=(const CIString& a, const char* b) { ... }friend bool operator<=(const CIString& a, const char* b) { ... }friend bool operator==(const char* a, const CIString& b) { ... }friend bool operator< (const char* a, const CIString& b) { ... }friend bool operator!=(const char* a, const CIString& b) { ... }friend bool operator> (const char* a, const CIString& b) { ... }friend bool operator>=(const char* a, const CIString& b) { ... }friend bool operator<=(const char* a, const CIString& b) { ... }};

In C++20, this requires only 4:

#include <iostream>
#include <string>
#include <string.h>int ci_compare(const char* p1, const char* p2)
{return strcmp(p1, p2);
}class CIString {
public:std::string s;bool operator==(const CIString& b) const {return s.size() == b.s.size() &&ci_compare(s.c_str(), b.s.c_str()) == 0;}std::weak_ordering operator<=>(const CIString& b) const {return ci_compare(s.c_str(), b.s.c_str()) <=> 0;}bool operator==(char const* b) const {return ci_compare(s.c_str(), b) == 0;}std::weak_ordering operator<=>(const char* b) const {return ci_compare(s.c_str(), b) <=> 0;}
};int main(void)
{CIString cis1{"CIString test1"};CIString cis2{"CIString test2"};const char* ccp = "ccccc";auto r1 = cis1 == cis2;auto r2 = cis1 == ccp;auto r3 = ccp == cis2;auto r4 = (cis1 <=> cis2 < 0);auto r5 = (cis1 <=> ccp < 0);std::cout << std::boolalpha << r1 << ' ' << r2 << ' ' << r3 << ' ' << r4 << ' ' << r5 << std::endl;
}

Defaulted operator<=> Implies Defaulted operator==

If and only if an operator<=> member is defined as defaulted, then by definition a corresponding operator== member is also defined if no defaulted operator== is provided. All aspects (visibility, virtual, attributes, requirements, etc.) are adopted. For example:

class Type {...public:[[nodiscard]] virtual std::strong_orderingoperator<=>(const Type&) const requires(!std::same_as<T,bool>) = default;};

is equivalent to the following:

template<typename T>class Type {...public:[[nodiscard]] virtual std::strong_orderingoperator<=> (const Type&) const requires(!std::same_as<T,bool>) = default;[[nodiscard]] virtual booloperator== (const Type&) const requires(!std::same_as<T,bool>) = default;};

operator == implies operator !=

For TypeA and TypeB:

struct TypeA
{   long id{};
};struct TypeB
{   long id{};
};bool operator==(const TypeA& a, const TypeB& b) noexcept
{return a.id == b.id;
}TypeA a; TypeB b;a == b; // OK: fits perfectlyb == a; // OK, rewritten as: a == ba != b; // OK, rewritten as: !(a == b)b != a; // OK, rewritten as: !(a == b)

Before C+20, you also need to implement following function:

bool operator==(const TypeB&, const TypeA&) noexcept{ … }bool operator!=(const TypeA&, const TypeB&) noexcept{ … }bool operator!=(const TypeB&, const TypeA&) noexcept{ … }

 

//C++17
#include <iostream>struct TypeA
{long id{};
};
struct TypeB
{long id{};
};
bool operator==(const TypeA& a, const TypeB& b) noexcept
{return a.id == b.id;
}
bool operator==(const TypeB& b, const TypeA& a) noexcept
{return a.id == b.id;
}
bool operator!=(const TypeA& a, const TypeB& b) noexcept
{return a.id != b.id;
}
bool operator!=(const TypeB& b, const TypeA& a) noexcept
{return a.id != b.id;
}
int main(void)
{TypeA a;TypeB b;auto r1 = a == b; // OK: fits perfectlyauto r2 = b == a; // OK, rewritten as: a == bauto r3 = a != b; // OK, rewritten as: !(a == b)auto r4 = b != a; // OK, rewritten as: !(a == b)std::cout << std::boolalpha << r1 << ' ' << r2 << ' ' << r3 << ' ' << r4 << std::endl;return 0;
}// C++20
#include <iostream>struct TypeA
{long id{};
};
struct TypeB
{long id{};
};
bool operator==(const TypeA& a, const TypeB& b) noexcept
{return a.id == b.id;
}int main(void)
{TypeA a;TypeB b;auto r1 = a == b; // OK: fits perfectlyauto r2 = b == a; // OK, rewritten as: a == bauto r3 = a != b; // OK, rewritten as: !(a == b)auto r4 = b != a; // OK, rewritten as: !(a == b)std::cout << std::boolalpha << r1 << ' ' << r2 << ' ' << r3 << ' ' << r4 << std::endl;return 0;
}// C++20: compare TypaA with TypeB
#include <iostream>
#include <compare>struct TypeB
{long id{};
};struct TypeA
{bool operator==(const TypeB& b) const noexcept{return this->id == b.id;}auto operator<=>(const TypeB& b) const noexcept{return this->id <=> b.id;}long id{};
};int main(void)
{TypeA a;TypeB b;auto r1 = a == b; // OK: fits perfectlyauto r2 = b == a; // OK, rewritten as: a == bauto r3 = a != b; // OK, rewritten as: !(a == b)auto r4 = b != a; // OK, rewritten as: !(a == b)std::cout << std::boolalpha << r1 << ' ' << r2 << ' ' << r3 << ' ' << r4 << std::endl;return 0;
}

You can define operator== and operator<=> yourself.

struct Context
{long Id;bool isSa{false};bool isNsa{false};…… //other fileds// for equality operators:bool operator== (const Context& rhs) const noexcept{return Id == rhs.Id; // defines equality (== and !=)}// for relational operators:auto operator <=> (const Context& rhs) const  noexcept{returneId <=> rhs.Id; //defines ordering (<, <=, >, and >=)}};

For UeContext x and y:

if   

x <= y  

does not find a matching definition of operator<=, it might be rewritten as

(x <=> y) <= 0   

or even   

0 <= (y <=> x)

As you can see by this rewriting, the new operator<=> performs a three-way comparison, which yields a value you can compare with 0:

• If the value of x<=>y is equal to 0, x and y are equal or equivalent.

• If the value of x<=>y is less than 0, x is less than y.

• If the value of x<=>y is greater than 0, x is greater than y.

The new operator <=> does not return a Boolean value. Instead, the return type is a type that signals the comparison category, which could be std::strong_ordering, std::weak_ordering or std::partial_ordering.

These types support the comparison with 0 to deal with the result.

One of the annoying difficulties in C++17 was actually writing out member-wise lexicographical comparisons. 

Use operator <=>

 

//C++20
#include <iostream>
#include <compare>
#include <tuple>struct A {int t;int u;int v;bool operator==(A const& rhs) const{return std::tie(t, u, v) == std::tie(rhs.t, rhs.u, rhs.v);}std::strong_ordering operator<=>(A const& rhs) const{// compare the T'sif (auto c = t <=> rhs.t; c != 0) return c;// .., then the U'sif (auto c = u <=> rhs.u; c != 0) return c;// ... then the V'sreturn v <=> rhs.v;}
};int main(void)
{A a1{10, 20, 30};A a2{10, 20, 30};std::cout << (a1 == a2) << std::endl;//Operator <=> takes precedence over all other comparison operatorsstd::cout << (a1 <=> a2 < 0) << std::endl;
}

 比较类别类型

<=> 操作符不返回布尔值，但其作用类似于三向比较，产生负值表示信号较少，正值表示信号
较大，0 表示信号相等或等效。这种行为类似于C 函数strcmp() 的返回值，也有一个重要的区别: 返
回值不是整数值，C++ 标准库提供了三种可能的返回类型，其反映了相应的比较类别。
比较类别
当比较两个值并按顺序排列时，有可能发生不同的“类别”行为:
• 对于强排序(也称为全排序)，给定类型的值都小于或等于或大于该类型的其他值(包括其本
身)。
这一类的典型例子是整数值或常见的字符串类型，字符串s1 小于等于或大于字符串s2。
若此类别的一个值既不小于也不大于另一个值，则两个值相等。若有多个对象，可以按升序
或降序进行排序(相等值的顺序任意)。
• 对于弱排序，给定类型的任何值都小于、等于或大于该类型的任何其他值(包括其本身)，但
相等的值不一定是相等的(具有相同的值)。
此类别的典型示例是用于不区分大小写的字符串的类型，字符串”hello” 小于”hello1” 且大
于”hell”。尽管，”hello” 与”HELLO” 这两个字符串不相等但等价。
若这个类别的值既不小于也不大于另一个值，那么这两个值至少是相等的(甚至可能是相等
的)。若有多个对象，则可以按升序或降序进行排序(相等值的顺序可以任意)。
• 对于偏排序，给定类型的任何值都可以小于、等于或大于该类型的任何其他值(包括其本身)，
可能根本不能指定两个值之间的特定顺序。
这种类型的典型示例是浮点类型，因为可能需要处理特殊值NaN(“非数字”)，任何值与NaN
的比较结果都为false。因此，比较可能导致两个值是无序的，并且比较操作符可能返回四个
值中的一个。
若有多个对象，可能无法按升序或降序对其进行排序(除非确保不存在无法排序的值)。

使用标准库比较类别
• std::strong_ordering 的值:
– std::strong_ordering::less
– std::strong_ordering::equal (也可是std::strong_ordering::equivalent)
– std::strong_ordering::greater
• std::weak_ordering 的值:
– std::weak_ordering::less
– std::weak_ordering::equivalent
– std::weak_ordering::greater
• std::partial_ordering 的值:
– std::partial_ordering::less
– std::partial_ordering::equivalent
– std::partial_ordering::greater
– std::partial_ordering::unordered
注意，所有类型都有less、greater 和equivalent 值。但strong_ordering 也有equal，这与这里的
equal 相同，而partial_ordering 的值为unordered，既不表示小于，等于和大于。
较强比较类型具有向较弱比较类型的隐式类型转换， 可以将strong_ordering 值用作
weak_ordering 值，或partial_ordering 值(相等则为equivalent)。

NaN an example with a partial ordering

Consider wanting to add a NaN state to int, where a NaN is simply not ordered with any engaged value. We can do this with std::optional as storage as follows:

 

struct IntNan 
{std::optional<int> val = std::nullopt;bool operator==(IntNan const& rhs) const {if (!val || !rhs.val) {return false;}return *val == *rhs.val;}partial_ordering operator<=>(IntNan const& rhs) const {if (!val || !rhs.val) {//we can express the unordered state as a first class valuereturn partial_ordering::unordered;}// <=> over int returns strong_ordering, but this is// implicitly convertible to partial_orderingreturn *val <=> *rhs.val;}
};

IntNan{2} <=> IntNan{4}; // partial_ordering::less
IntNan{2} <=> IntNan{};  // partial_ordering::unorderedIntNan{2} < IntNan{4};   // true
IntNan{2} < IntNan{};    // false
IntNan{2} == IntNan{};   // false
IntNan{2} <= IntNan{};   // falsestrong_ordering::less < 0     // true
strong_ordering::less == 0    // false
strong_ordering::less != 0    // true
strong_ordering::greater >= 0 // truepartial_ordering::less < 0    // true
partial_ordering::greater > 0 // true// unordered is a special value that isn't
// comparable against anything
partial_ordering::unordered < 0  // false
partial_ordering::unordered == 0 // false
partial_ordering::unordered > 0  // false

 学生成绩在班级和年级中的排名，当学生成绩没有出来时无法比较

//student score, class and school
#include <iostream>
#include <compare>
#include <optional>struct IntNan 
{std::optional<int> val = std::nullopt;bool operator==(IntNan const& rhs) const {if (!val || !rhs.val) {return false;}return *val == *rhs.val;}std::partial_ordering operator<=>(IntNan const& rhs) const {if (!val || !rhs.val) {//we can express the unordered state as a first class valuereturn std::partial_ordering::unordered;}// <=> over int returns strong_ordering, but this is// implicitly convertible to partial_orderingreturn *val <=> *rhs.val;}
};int main(void)
{// partial_ordering::lessstd::cout << (IntNan{2} <=> IntNan{4} < 0) << std::endl; // partial_ordering::unorderedstd::cout << (IntNan{2} <=> IntNan{} == std::partial_ordering::unordered) << std::endl; std::cout << (IntNan{2} < IntNan{4}) << std::endl;   // truestd::cout << (IntNan{2} < IntNan{}) << std::endl;    // falsestd::cout << (IntNan{2} == IntNan{}) << std::endl;   // falsestd::cout << (IntNan{2} <= IntNan{}) << std::endl;   // false}

处理多种排序条件

要基于多个属性计算运算符<=> 的结果，通常可以实现一连串的子比较，直到结果不相等或到
达要最终属性的比较:

但若属性具有不同的比较类别，则返回类型不会编译。例如，若成员名是string 类型，而成员
值是double 类型，则返回类型会冲突: 

 

可以使用到最弱比较类型的转换。若已知最弱的比较类型，可以声明为返回类型: 

 

若不知道比较类型(例如， 类型是模板形参)， 可以使用新的类型特征
std::common_comparison_category<> 来计算最强的比较类型:

 

通过使用尾部返回类型语法(auto 在前面，返回类型在-> 后面)，可以使用参数来计算比较类型。
这种情况下，可以只使用name，而非rhs.name，这种方法通常是有效的(例如，也适用于独立函数)。
若希望提供比内部使用的类别更强的类别，则必须将内部比较的所有可能值映射到返回类型的
值。若不能映射某些值，这可能包括一些错误处理。例如:

#include <iostream>
#include <string>
#include <compare>
#include <cassert>#if 1
struct Person 
{
std::string name;
double value;std::partial_ordering operator<=> (const Person& rhs) const { // OKauto cmp1 = name <=> rhs.name;if (cmp1 != 0) return cmp1; // strong_ordering converted to return typereturn value <=> rhs.value; // partial_ordering used as the return type}
};
#endif#if 0
struct Person 
{
std::string name;
double value;auto operator<=> (const Person& rhs) const // OK-> std::common_comparison_category_t<decltype(name <=> rhs.name),decltype(value <=> rhs.value)> {auto cmp1 = name <=> rhs.name;if (cmp1 != 0) return cmp1; // used as or converted to common comparison typereturn value <=> rhs.value; // used as or converted to common comparison type}
};
#endif#if 0
struct Person {
std::string name;
double value;std::strong_ordering operator<=> (const Person& rhs) const {auto cmp1 = name <=> rhs.name;if (cmp1 != 0) return cmp1; // return strong_ordering for std::stringauto cmp2 = value <=> rhs.value; // might be partial_ordering for double// map partial_ordering to strong_ordering:assert(cmp2 != std::partial_ordering::unordered); // RUNTIME ERROR if unorderedreturn cmp2 == 0 ? std::strong_ordering::equal: cmp2 > 0 ? std::strong_ordering::greater: std::strong_ordering::less;}
};
#endifint main(void)
{Person p1{"zhangsan", 11.1};Person p2{"zhangsan", 22.2};std::cout << (p1 <= p2) << std::endl;}

对于空类，默认操作符比较所有对象为相等:==、<= 和>= 生成true，!=、< 和> 生成false，而
<=> 生成std::strong_ordering::equal。

 默认<=> 操作符实现默认== 操作符
当操作符<=> 成员定义为默认值时，若没有提供默认操作符==，则根据定义也定义相应的操
作符== 成员，可采用相应的方式(可见性、虚拟、属性、需求等)。例如:

Compatibility issues with the comparison operators 

 

//C++17 OK
#include <iostream>class MyType{
public:MyType(int i)    // implicit constructor from int:: value{i}{}bool operator==(const MyType& rhs) const { return value == rhs.value; }
private:int value;
};bool operator==(int i, const MyType& t)
{return t == i;// OK with C++17 ==>call: t.operator==(MyType(i));
}int main()
{MyType x = 42;if (42 == x){std::cout << "'42 == MyType{42}' works\n";}
}

Unfortunately, this code no longer works in C++20. It results in an endless recursion.

This is because inside the global function, the expression can also call the global operator==() itself. Because the compiler also tries to rewrite the call as

bool operator==(int i, const MyType& t)

{

    return t == i; /* compiler finds #1:   operator==(i,t)  => not need to implicit type coversion

                                                and   #2:   t.operator(MyType{i}) => need to implicit type coversion

                            #1 is better match than #2

                           */

}

Solution :

1. Code only work with C++20: remove the free-standing function

2. Otherwise, you can use an explicit conversion:

bool operator==(int i, const MyType& t)

{

        return t == MyType{i}; // OK until C++17 and with C++20

}

// test log:
#include <iostream>
class MyType{
public:MyType(int i)    // implicit constructor from int:: value{i}{}bool operator==(const MyType& rhs) const {std::cout << "operator== member" << std::endl;return value == rhs.value;}private:int value;
};bool operator==(int i, const MyType& t){std::cout << "operator == free function" << std::endl;return t == i;// OK with C++17 ==>call: t.operator==(MyType(i));
}int main(){MyType x = 42;if (42 == x){std::cout << "'42 == MyType{42}' works\n";}
}