C++20标准新引入了一个名为“太空飞船”（spaceship）的运算符<=>，它是一个三向比较运算符。<=>之所以被称为“太空飞船”运算符是因为<=>让著名的Perl语言专家兰德尔·L.施瓦茨想起1971年的一款电子游戏《星际迷航》中的太空飞船。读者应该也看出来了，<=>并不是C++20首创的，实际上Perl、PHP、Ruby等语言早已支持了三向比较运算符，C++是后来的学习者。
顾名思义，三向比较就是在形如lhs <=> rhs的表达式中，两个比较的操作数lhs和rhs通过<=>比较可能产生3种结果，该结果可以和0比较，小于0、等于0或者大于0分别对应lhs < rhs、lhs == rhs和lhs > rhs。举例来说：
bool b = 7 <=> 11 < 0; // b == true请注意，运算符<=>的返回值只能与0和自身类型来比较，如果同其他数值比较，编译器会报错：
bool b = 7 <=> 11 < 100; // 编译失败，<=>的结果不能与除0以外的数值比较可以看出<=>的返回结果并不是一个普通类型，根据标准，三向比较会返回3种类型，分别为std::strong_ordering、std::weak_ordering以及std:: partial_ordering，而这3种类型又会分为有3～4种最终结果，下面就来一一介绍它们。
std::strong_ordering类型有3种比较结果，分别为std::strong_ ordering::less、std::strong_ordering::equal以及std::strong_ ordering::greater。表达式lhs <=> rhs分别表示lhs < rhs、lhs == rhs以及lhs > rhs。std::strong_ordering类型的结果强调的是strong的含义，表达的是一种可替换性，简单来说，若lhs == rhs，那么在任何情况下rhs和lhs都可以相互替换，也就是fx(lhs) == fx(rhs)。
对于基本类型中的int类型，三向比较返回的是std::strong_ordering，例如：
std::cout << typeid(decltype(7 <=> 11)).name();用MSVC编译运行以上代码，会在输出窗口显示class std::strong_ ordering，刻意使用MSVC是因为它的typeid(x).name()可以输出友好可读的类型名称。对于有复杂结构的类型，std::strong_ordering要求其数据成员和基类的三向比较结果都为std::strong_ordering。例如：
#include <compare>
struct B
{
int a;
long b;
auto operator <=> (const B&) const = default;
};
struct D : B
{
short c;
auto operator <=> (const D&) const = default;
};
D x1, x2;
std::cout << typeid(decltype(x1 <=> x2)).name();上面这段代码用MSVC编译运行会输出class std::strong_ordering。请注意，默认情况下自定义类型是不存在三向比较运算符函数的，需要用户显式默认声明，比如在结构体B和D中声明auto operator <=> (const B&) const = default;和auto operator <=> (const D&) const = default;。对结构体B而言，由于int和long的比较结果都是std::strong_ordering，因此结构体B的三向比较结果也是std::strong_ordering。同理，对于结构体D，其基类和成员的比较结果是std::strong_ordering，D的三向比较结果同样是std::strong_ordering。另外，明确运算符的返回类型，使用std::strong_ ordering替换auto也是没问题的。
std::weak_ordering类型也有3种比较结果，分别为std::weak_ ordering::less、std::weak_ordering::equivalent以及std::weak_ ordering::greater。std::weak_ordering的含义正好与std::strong_ ordering相对，表达的是不可替换性。即若有lhs == rhs，则rhs和lhs不可以相互替换，也就是fx(lhs) != fx(rhs)。这种情况在基础类型中并没有，但是它常常发生在用户自定义类中，比如一个大小写不敏感的字符串类：
#include <compare>
#include <string>
int ci_compare(const char* s1, const char* s2)
{
while (tolower(*s1) == tolower(*s2++)) {
if (*s1++ == '\0') {
return 0;
}
}
return tolower(*s1) - tolower(*--s2);
}
class CIString {
public:
CIString(const char *s) : str_(s) {}
std::weak_ordering operator<=>(const CIString& b) const {
return ci_compare(str_.c_str(), b.str_.c_str()) <=> 0;
}
private:
std::string str_;
};
CIString s1{ "HELLO" }, s2{"hello"};
std::cout << (s1 <=> s2 == 0); // 输出为true以上代码实现了一个简单的大小写不敏感的字符串类，它对于s1和s2的比较结果是std::weak_ordering::equivalent，表示两个操作数是等价的，但是它们不是相等的也不能相互替换。当std::weak_ordering和std::strong_ ordering同时出现在基类和数据成员的类型中时，该类型的三向比较结果是std::weak_ordering，例如：
struct D : B
{
CIString c{""};
auto operator <=> (const D&) const = default;
};
D w1, w2;
std::cout << typeid(decltype(w1 <=> w2)).name();用MSVC编译运行上面这段代码会输出class std::weak_ordering，因为D中的数据成员CIString的三向比较结果为std::weak_ordering。请注意，如果显式声明默认三向比较运算符函数为std::strong_ordering operator <=> (const D&) const = default;，那么一定会遭遇到一个编译错误。
std::partial_ordering类型有4种比较结果，分别为std::partial_ ordering::less、std::partial_ordering::equivalent、std::partial_ ordering::greater以及std::partial_ordering::unordered。std:: partial_ordering约束力比std::weak_ordering更弱，它可以接受当lhs == rhs时rhs和lhs不能相互替换，同时它还能给出第四个结果std::partial_ ordering::unordered，表示进行比较的两个操作数没有关系。比如基础类型中的浮点数：
std::cout << typeid(decltype(7.7 <=> 11.1)).name();用MSVC编译运行以上代码会输出class std::partial_ordering。之所以会输出class std::partial_ordering而不是std::strong_ordering，是因为浮点的集合中存在一个特殊的NaN，它和其他浮点数值是没关系的：
std::cout << ((0.0 / 0.0 <=> 1.0) == std::partial_ordering::unordered);这段代码编译输出的结果为true。当std::weak_ordering和std:: partial_ordering同时出现在基类和数据成员的类型中时，该类型的三向比较结果是std::partial_ordering，例如：
struct D : B
{
CIString c{""};
float u;
auto operator <=> (const D&) const = default;
};
D w1, w2;
std::cout << typeid(decltype(w1 <=> w2)).name();用MSVC编译运行以上代码会输出class std::partial_ordering，因为D中的数据成员u的三向比较结果为std::partial_ordering，同样，显式声明为其他返回类型也会让编译器报错。在C++20的标准库中有一个模板元函数std::common_comparison_category，它可以帮助我们在一个类型合集中判断出最终三向比较的结果类型，当类型合集中存在不支持三向比较的类型时，该模板元函数返回void。
再次强调一下，std::strong_ordering、std::weak_ordering和std::partial_ordering只能与0和类型自身比较。深究其原因，是这3个类只实现了参数类型为自身类型和nullptr_t的比较运算符函数。
1．对两个算术类型的操作数进行一般算术转换，然后进行比较。其中整型的比较结果为std::strong_ordering，浮点型的比较结果为std::partial_ordering。例如7 <=> 11.1中，整型7会转换为浮点类型，然后再进行比较，最终结果为std::partial_ordering类型。
2．对于无作用域枚举类型和整型操作数，枚举类型会转换为整型再进行比较，无作用域枚举类型无法与浮点类型比较：
enum color {
red
};
auto r = red <=> 11; //编译成功
auto r = red <=> 11.1; //编译失败3．对两个相同枚举类型的操作数比较结果，如果枚举类型不同，则无法编译。
4．对于其中一个操作数为bool类型的情况，另一个操作数必须也是bool类型，否则无法编译。比较结果为std::strong_ordering。
5．不支持作比较的两个操作数为数组的情况，会导致编译出错，例如：
int arr1[5];
int arr2[5];
auto r = arr1 <=> arr2; // 编译失败6．对于其中一个操作数为指针类型的情况，需要另一个操作数是同样类型的指针，或者是可以转换为相同类型的指针，比如数组到指针的转换、派生类指针到基类指针的转换等，最终比较结果为std::strong_ordering：
char arr1[5];
char arr2[5];
char* ptr = arr2;
auto r = ptr <=> arr1;上面的代码可以编译成功，若将代码中的arr1改写为int arr1[5]，则无法编译，因为int [5]无法转换为char *。如果将char * ptr = arr2;修改为void * ptr = arr2;，代码就可以编译成功了。
标准库中提供了一个名为std::rel_ops的命名空间，在用户自定义类型已经提供了==运算符函数和<运算符函数的情况下，帮助用户实现其他4种运算符函数，包括!=、>、<=和>=，例如：
#include <string>
#include <utility>
class CIString2 {
public:
CIString2(const char* s) : str_(s) {}
bool operator < (const CIString2& b) const {
return ci_compare(str_.c_str(), b.str_.c_str()) < 0;
}
private:
std::string str_;
};
using namespace std::rel_ops;
CIString2 s1{ "hello" }, s2{ "world" };
bool r = s1 >= s2;不过因为C++20标准有了三向比较运算符的关系，所以不推荐上面这种做法了。C++20标准规定，如果用户为自定义类型声明了三向比较运算符，那么编译器会为其自动生成<、>、<=和>=这4种运算符函数。对于CIString我们可以直接使用这4种运算符函数：
CIString s1{ "hello" }, s2{ "world" };
bool r = s1 >= s2;那么这里就会产生一个疑问，很明显三向比较运算符能表达两个操作数是相等或者等价的含义，为什么标准只允许自动生成4种运算符函数，却不能自动生成==和=!这两个运算符函数呢？实际上这里存在一个严重的性能问题。在C++20标准拟定三向比较的早期，是允许通过三向比较自动生成6个比较运算符函数的，而三向比较的结果类型也不是3种而是5种，多出来的两种分别是std::strong_ equality和std::weak_equality。但是在提案文档p1190中提出了一个严重的性能问题。简单来说，假设有一个结构体：
struct S {
std::vector<std::string> names;
auto operator<=>(const S &) const = default;
};它的三向比较运算符的默认实现这样的：
template<typename T>
std::strong_ordering operator<=>(const std::vector<T>& lhs, const std::vector<T> & rhs)
{
size_t min_size = min(lhs.size(), rhs.size());
for (size_t i = 0; i != min_size; ++i) {
if (auto const cmp = std::compare_3way(lhs[i], rhs[i]); cmp != 0) {
return cmp;
}
}
return lhs.size() <=> rhs.size();
}这个实现对于<和>这样的运算符函数没有问题，因为需要比较容器中的每个元素。但是==运算符就显得十分低效，对于==运算符高效的做法是先比较容器中的元素数量是否相等，如果元素数量不同，则直接返回false：
template<typename T>
bool operator==(const std::vector<T>& lhs, const std::vector<T>& rhs)
{
const size_t size = lhs.size();
if (size != rhs.size()) {
return false;
}
for (size_t i = 0; i != size; ++i) {
if (lhs[i] != rhs[i]) {
return false;
}
}
return true;
}想象一下，如果标准允许用三向比较的算法自动生成==运算符函数会发生什么事情，很多旧代码升级编译环境后会发现运行效率下降了，尤其是在容器中元素数量众多且每个元素数据量庞大的情况下。很少有程序员会注意到三向比较算法的细节，导致这个性能问题难以排查。基于这种考虑，C++委员会修改了原来的三向比较提案，规定声明三向比较运算符函数只能够自动生成4种比较运算符函数。由于不需要负责判断是否相等，因此std::strong_equality和std::weak_ equality也退出了历史舞台。对于==和!=两种比较运算符函数，只需要多声明一个==运算符函数，!=运算符函数会根据前者自动生成：
class CIString {
public:
CIString(const char* s) : str_(s) {}
std::weak_ordering operator<=>(const CIString& b) const {
return ci_compare(str_.c_str(), b.str_.c_str()) <=> 0;
}
bool operator == (const CIString& b) const {
return ci_compare(str_.c_str(), b.str_.c_str()) == 0;
}
private:
std::string str_;
};
CIString s1{ "hello" }, s2{ "world" };
bool r1 = s1 >= s2; // 调用operator<=>
bool r2 = s1 == s2; // 调用operator ==现在C++20标准已经推荐使用<=>和==运算符自动生成其他比较运算符函数，而使用<、==以及std::rel_ops生成其他比较运算符函数则会因为std::rel_ops已经不被推荐使用而被编译器警告。那么对于老代码，我们是否需要去实现一套<=>和==运算符函数呢？其实大可不必，C++委员会在裁决这项修改的时候已经考虑到老代码的维护成本，所以做了兼容性处理，即在用户自定义类型中，实现了<、==运算符函数的数据成员类型，在该类型的三向比较中将自动生成合适的比较代码。比如：
struct Legacy {
int n;
bool operator==(const Legacy& rhs) const
{
return n == rhs.n;
}
bool operator<(const Legacy& rhs) const
{
return n < rhs.n;
}
};
struct TreeWay {
Legacy m;
std::strong_ordering operator<=>(const TreeWay &) const = default;
};
TreeWay t1, t2;
bool r = t1 < t2;在上面的代码中，结构体TreeWay的三向比较操作会调用结构体Legacy中的<和==运算符来完成，其代码类似于：
struct TreeWay {
Legacy m;
std::strong_ordering operator<=>(const TreeWay& rhs) const {
if (m < rhs.m) return std::strong_ordering::less;
if (m == rhs.m) return std::strong_ordering::equal;
return std::strong_ordering::greater;
}
};需要注意的是，这里operator<=>必须显式声明返回类型为std::strong_ ordering，使用auto是无法通过编译的。
本章介绍了C++20新增的三向比较特性，该特性的引入为实现比较运算提供了方便。我们只需要实现==和<=>两个运算符函数，剩下的4个运算符函数就可以交给编译器自动生成了。虽说std::rel_ops在实现了==和<两个运算符函数以后也能自动提供剩下的4个运算符函数，但显然用三向比较更加便捷。另外，三向比较提供的3种结果类型也是std::rel_ops无法媲美的。进一步来说，由于三向比较的出现，std::rel_ops在C++20中已经不被推荐使用了。最后，C++委员会没有忘记兼容性问题，这让三向比较能够通过运算符函数<和==来自动生成。