默认比较(C++20 起)

来自cppreference.com
< cpp‎ | language

提供一种方式,以要求编译器为某个类生成相一致的关系运算符。

简言之,定义了 operator<=> 的类自动获得由编译器生成的运算符 ==、!=、<、<=、> 和 >=。类可以将 operator<=> 定义为预置的,这种情况下编译器亦将为该运算符生成代码。

class Point {
 int x;
 int y;
public:
 auto operator<=>(const Point&) const = default;
 // ……非比较函数……
};
// 编译器生成全部六个关系运算符
Point pt1, pt2;
if (pt1 == pt2) { /*...*/ } // OK
std::set<Point> s; // OK
s.insert(pt1); // OK
if (pt1 <= pt2) { /*...*/ } // OK,只调用一次 <=>

目录

[编辑] 定制比较

如果预置的语义不适合,例如在必须不按各成员的顺序进行比较,或必须用某种不同于它们的自然比较操作的比较,这种情况下程序员可以编写 operator<=> 并令编译器生成适合的关系运算符。生成的关系运算符种类取决于用户定义 operator<=> 的返回类型。

有五种可用的返回类型:

返回类型 运算符 等价的值…… 不可比较的值……
std::strong_ordering == != < > <= >= 不可区分 不允许存在
std::weak_ordering == != < > <= >= 可区分 不允许存在
std::partial_ordering == != < > <= >= 可区分 允许存在
std::strong_equality == != 不可区分 不允许存在
std::weak_equality == != 可区分 不允许存在

[编辑] 强序

一个返回 std::strong_ordering 的定制 operator<=> 的例子是,对类的每个成员进行比较的运算符,但与默认的顺序有所不同(此处为姓优先)

class TotallyOrdered : Base {
  std::string tax_id;
  std::string first_name;
  std::string last_name;
public:
 // 定制 operator<=>,因为我们想先比较姓
 std::strong_ordering operator<=>(const TotallyOrdered& that) const {
   if (auto cmp = (Base&)(*this) <=> (Base&)that; cmp != 0) return cmp;
   if (auto cmp = last_name <=> that.last_name; cmp != 0) return cmp;
   if (auto cmp = first_name <=> that.first_name; cmp != 0) return cmp;
   return tax_id <=> that.tax_id;
 }
 // ……非比较函数……
};
// 编译器生成全部 6 个关系运算符
TotallyOrdered to1, to2;
if (to1 == to2) { /*...*/ } // ok
std::set<TotallyOrdered> s; // ok
s.insert(to1); // ok
if (to1 <= to2) { /*...*/ } // ok,调用一次 <=>

注意:返回 std::strong_ordering 的运算符应该对所有成员都进行比较,因为遗漏了任何成员都将会损害可替换性:二个比较相等的值可能变得可以区分。

[编辑] 弱序

一个返回 std::weak_ordering 的定制 operator<=> 的例子是,以大小写无关方式比较类的字符串成员的运算符:这不同于默认比较(故要求定制运算符),并且在这种比较下有可能对比较相等的两个字符串加以区分

class CaseInsensitiveString {
  std::string s;
public:
  std::weak_ordering operator<=>(const CaseInsensitiveString& b) const {
    return case_insensitive_compare(s.c_str(), b.s.c_str());
  }
  std::weak_ordering operator<=>(const char* b) const {
    return case_insensitive_compare(s.c_str(), b);
  }
  // ……非比较函数……
};
 
// 编译器生成全部 6 个关系运算符
CaseInsensitiveString cis1, cis2;
if (cis1 == cis2) { /*...*/ } // ok
set<CaseInsensitiveString> s; // ok
s.insert(/*...*/); // ok
if (cis1 <= cis2) { /*...*/ } // ok,进行一次比较运算
 
// 编译器亦生成全部 12 个异相关系运算符
if (cis1 <= "xyzzy") { /*...*/ } // ok,进行一次比较运算
if ("xyzzy" >= cis1) { /*...*/ } // ok,等同的语义

注意,此示例演示了异质 operator<=> 所具有的效果:它在两个方向都生成了异质的比较。

[编辑] 偏序

偏序是允许存在不可比较(无序)值的排序,例如浮点排序中的 NaN 值,或这个例子中的无关人员:

class PersonInFamilyTree { // ……
public:
  std::partial_ordering operator<=>(const PersonInFamilyTree& that) const {
    if (this->is_the_same_person_as ( that)) return partial_ordering::equivalent;
    if (this->is_transitive_child_of( that)) return partial_ordering::less;
    if (that. is_transitive_child_of(*this)) return partial_ordering::greater;
    return partial_ordering::unordered;
  }
  // ……非比较函数……
};
// 编译器生成全部六个关系运算符
PersonInFamilyTree per1, per2;
if (per1 == per2) { /*...*/ } // ok,per1 为 per2
else if (per1 < per2) { /*...*/ } // ok,per2 是 per1 的祖先
else if (per1 > per2) { /*...*/ } // ok,per1 是 per2 的祖先
else { /*...*/ } // per1 与 per2 无关
if (per1 <= per2) { /*...*/ } // ok,per2 是 per1 或 per1 的祖先
if (per1 >= per2) { /*...*/ } // ok,per1 是 per2 或 per2 的祖先
if (per1 != per2) { /*...*/ } // ok,per1 不是 per2

[编辑] 强相等

有许多类型,相等对它们有意义,但小于顺序无意义:常见的例子是复数,或通常的任何数对:

class EqualityComparable {
  std::string name;
  BigInt number1;
  BigInt number2;
public:
  std::strong_equality operator<=>(const EqualityComparable& that) const {
    if (auto cmp = number1 <=> that.number1; cmp != 0) return cmp;
    if (auto cmp = number2 <=> that.number2; cmp != 0) return cmp;
    return name <=> that.name;
  }
};
// 编译器生成 == 和 !=,但不生成 < > <= 或 >=
EqualityComparable ec1, ec2;
if (ec1 != ec2) { /*...*/ } // ok

[编辑] 弱相等

此例中,这种比较下比较相等的两个值(在成员 name 上无关大小写),可被关乎大小写的函数所区分:

class EquivalenceComparable {
  CaseInsensitiveString name;
  BigInt number1;
  BigInt number2;
public:
  std::weak_equality operator<=>(const EquivalenceComparable& that) const {
    if (auto cmp = number1 <=> that.number1; cmp != 0) return cmp;
    if (auto cmp = number2 <=> that.number2; cmp != 0) return cmp;
    return name <=> that.name;
 }
 // ……非比较函数……
};
// 编译器生成 == 和 !=,但不生成 < > <= 或 >=
EquivalenceComparable ec1, ec2;
if (ec1 != ec2) { /*...*/ } // ok

[编辑] 预置的三路比较

预置的运算符 operator<=> 进行字典序比较,通过相继地比较 T 的基类(从左到右,深度优先)然后是非静态成员子对象(以声明顺序)计算 <=>,递归地(以下标递增顺序)展开数组成员,并在找到不相等结果时尽早停止,即:

for /* T 的每个成员或基类子对象 */
  if (auto cmp = lhs.o <=> rhs.o; cmp != 0) return cmp;
return strong_ordering::equal; // 转换到任何比较结果

虚基类子对象是否进行多于一次的比较是未指明的。

若声明返回类型为 auto,则实际返回类型为 std::common_comparison_category_t<Ms>,其中 Ms 是待比较的基类和成员子对象和成员数组元素的列表(可能为空)。这使得返回类型非平凡地依赖于成员的情况更容易编写,例如:

template<class T1, class T2>
struct P {
 T1 x1;
 T2 x2;
 auto operator<=>(const P&, const P&) = default;
};

否则,返回类型必须是五个比较类型之一(见上文),且若表达式 m1 <=> m2 对于任何基类或成员子对象或成员数组元素不可隐式转换为选择的返回类型,则程序非良构。

如果并非所有基类和成员子对象在其作用域中(即作为非静态成员或友元)都拥有一个编译器生成或用户声明的 operator<=>,且其结果是 std:: 中的比较类别类型之一,则预置的 operator<=> 被隐式弃置并返回 void

[编辑] 预置的双路比较

六个双路关系运算符的任何一个都能显式预置。预置的关系运算符必须拥有返回类型 bool

若 x <=> y 上的重载决议(同时考虑带有逆序参数的 operator<=>)失败,或此 operator@ 不可应用到该 x<=>y 的结果,则这种运算符将被弃置。否则,若重载决议选择了带参数原顺序的 operator<=>,则预置的 operator@ 调用 x <=> y @ 0,否则调用 0 @ y <=> x

struct C {
  friend std::strong_equality operator<=>(const C&, const C&);
  friend bool operator==(const C& x, const C& y) = default; // ok,返回 x <=> y == 0
  bool operator<(const C&) = default;                       // ok,函数被弃置
};

关系运算符的预置在创建可以取地址的函数时有用。对于其他用途,仅提供 operator<=> 就足够了。

[编辑] 参阅