デフォルト比較(C++20以上)

class Point {
 int x;
 int y;
public:
 auto operator<=>(const Point&) const = default;
 // ... その他の無関係な関数 ...
};
// コンパイラは6つの関係演算子すべてを生成します。
Point pt1, pt2;
if (pt1 == pt2) { /*...*/ } // OK。
std::set<Point> s; // OK。
s.insert(pt1); // OK。
if (pt1 <= pt2) { /*...*/ } // OK、 <=> を1回だけ呼びます。

class TotallyOrdered : Base {
  std::string tax_id;
  std::string first_name;
  std::string last_name;
public:
 // last_name を最初に比較したいカスタム 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、 <=> を1回呼びます。

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、比較演算を1回行います。
 
// コンパイラは12個の異種混合関係演算子も生成します。
if (cis1 <= "xyzzy") { /*...*/ } // OK、比較演算を1回行います。
if ("xyzzy" >= cis1) { /*...*/ } // OK、上と同じセマンティクス。

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;
  }
  // ... その他の無関係な関数 ...
};
// コンパイラは6つの関係演算子すべてを生成します。
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。

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。

for /* T のそれぞれの基底およびメンバ部分オブジェクト o */
  if (auto cmp = lhs.o <=> rhs.o; cmp != 0) return cmp;
return strong_ordering::equal; // すべてに変換します。

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

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、関数は削除されます。
};