默认比较(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<=> 就足够了。

[编辑] 参阅