operator<=>

Оператор <=> ("spaceship") — оператор трёхстороннего сравнения: одна функция, из определения которой компилятор автоматически синтезирует все шесть операторов сравнения (==, !=, <, <=, >, >=), если они не написаны отдельно. Он не возвращает bool — его результат один из специальных типов category сравнения (std::strong_ordering, std::weak_ordering, std::partial_ordering), кодирующий не просто факт "меньше/больше", а категорию упорядочения самого типа.The <=> ("spaceship") operator is the three-way comparison operator: a single function from whose definition the compiler automatically synthesizes all six comparison operators (==, !=, <, <=, >, >=) when they aren't written separately. It doesn't return bool — its result is one of the special ordering-category types (std::strong_ordering, std::weak_ordering, std::partial_ordering), which encodes not just "less/greater" but the ordering category of the type itself.

struct Point {
    int x, y;
    bool operator==(const Point& o) const { return x == o.x && y == o.y; }
    bool operator!=(const Point& o) const { return !(*this == o); }
    bool operator<(const Point& o) const { return x < o.x || (x == o.x && y < o.y); }
    bool operator<=(const Point& o) const { return !(o < *this); }
    bool operator>(const Point& o) const { return o < *this; }
    bool operator>=(const Point& o) const { return !(*this < o); }
    // добавили новое поле z — нужно синхронно поправить все шесть// added a new field z — all six now need updating in sync
};

struct Point {
    int x, y;
    auto operator<=>(const Point&) const = default;
    // == , !=, <, <=, >, >= — все шесть уже доступны// == , !=, <, <=, >, >= — all six already available
};

До C++20 класс, желающий поддержать полное упорядочение, был обязан вручную писать все шесть операторов сравнения — рутинный и подверженный ошибкам boilerplate:Before C++20, a class that wanted to support full ordering had to hand-write all six comparison operators — routine, error-prone boilerplate:

a <=> b возвращает не bool, а объект одного из трёх типов категории сравнения. Компилятор транслирует выражения вроде a < b в (a <=> b) < 0 — эти типы перегружают сравнение с литералом 0, так что остальные пять операторов синтезируются автоматически из единственного определения <=>, если сам класс их не определяет отдельно. При = default компилятор генерирует лексикографическое сравнение по членам в порядке их объявления — ровно как если бы каждый член сравнивался по очереди, пока не найдётся первое отличие.An expression a <=> b returns not a bool but an object of one of three ordering-category types. The compiler translates expressions like a < b into (a <=> b) < 0 — these types overload comparison against the literal 0, so the remaining five operators are synthesized automatically from a single <=> definition, unless the class defines them separately. With = default, the compiler generates a member-wise lexicographic comparison in declaration order — exactly as if each member were compared in turn until the first difference is found.

struct Point {
    int x, y;
    auto operator<=>(const Point&) const = default;
    // = default для <=> на агрегате из int-ов также генерирует ==// = default for <=> on an int-only aggregate also generates ==
};

Point a{1, 2}, b{1, 3};
bool less = a < b;   // компилятор: (a <=> b) < 0 → сравнивает x, затем y// compiler: (a <=> b) < 0 → compares x, then y

// case, где нужно явное определение — регистронезависимая строка:// a case needing an explicit definition — a case-insensitive string:
struct CiString {
    std::string s;
    std::weak_ordering operator<=>(const CiString& o) const {
        return to_lower(s) <=> to_lower(o.s);
        // weak_ordering: "Abc" и "abc" равны при сравнении,// weak_ordering: "Abc" and "abc" compare equal,
        // но не идентичны побайтово — не strong_ordering// but aren't byte-identical — not strong_ordering
    }
    bool operator==(const CiString& o) const {
        return to_lower(s) == to_lower(o.s);  // пишется отдельно, не выводится из <=>// written separately, not derived from <=>
    }
};

Историческая причина, по которой == не выводится из <=> автоматически по умолчанию (если только оба не сгенерированы через = default одновременно) — производительность: равенство часто можно проверить быстрее, чем полное упорядочение (например, сравнение строк на равенство может завершиться на первом же различии длины, тогда как для получения порядка нужно досравнить содержимое). Заставлять == всегда идти через полный <=> означало бы платить за упорядочение там, где нужен был только факт равенства.The historical reason == isn't derived from <=> automatically by default (unless both are generated via = default together) is performance: equality can often be checked faster than full ordering (for instance, comparing strings for equality can short-circuit on a length mismatch alone, while producing an order requires comparing the actual contents). Forcing == to always go through a full <=> would mean paying for ordering where only an equality fact was needed.

Иногда сравнение объекта не является лексикографическим по хранимым полям вообще — например, версия вида major.minor.patch хранится как три числа, но "правильное" сравнение версий семантически не отличается от лексикографического по этим же трём полям в этом конкретном случае. Однако если версия хранится, скажем, вместе с necessary pre-release суффиксом ("1.2.0-rc1" < "1.2.0" по семантике semver, хотя строка "1.2.0-rc1" лексикографически больше строки "1.2.0"), сравнение по полям структуры данных перестаёт совпадать с сравнением по значению — и <=> приходится писать вручную, инкапсулируя это несовпадение:Sometimes an object's comparison isn't lexicographic over its stored fields at all — for instance, a major.minor.patch version is stored as three numbers, and in that particular case "correct" version comparison happens to coincide with lexicographic comparison over those same three fields. But if the version is stored together with, say, a pre-release suffix ("1.2.0-rc1" < "1.2.0" under semver semantics, even though the string "1.2.0-rc1" is lexicographically greater than the string "1.2.0"), comparing the data structure's fields stops matching comparison by value — and <=> has to be hand-written to encapsulate that mismatch:

struct SemVer {
    int major, minor, patch;
    std::string prerelease;   // "" для релиза, "rc1"/"beta2" для пре-релиза// "" for a release, "rc1"/"beta2" for a pre-release

    std::strong_ordering operator<=>(const SemVer& o) const {
        if (auto c = major <=> o.major; c != 0) return c;
        if (auto c = minor <=> o.minor; c != 0) return c;
        if (auto c = patch <=> o.patch; c != 0) return c;
        // семантика semver: пустой prerelease ("релиз") всегда СТАРШЕ непустого —// semver semantics: an empty prerelease ("a release") always outranks a non-empty one —
        // это НЕ то же самое, что лексикографическое сравнение строк prerelease// this is NOT the same as a lexicographic comparison of the prerelease strings
        if (prerelease.empty() && o.prerelease.empty()) return std::strong_ordering::equal;
        if (prerelease.empty())   return std::strong_ordering::greater;
        if (o.prerelease.empty()) return std::strong_ordering::less;
        return prerelease <=> o.prerelease;
    }
    bool operator==(const SemVer& o) const = default;
};
// = default здесь дал бы "1.2.0" < "1.2.0-rc1" — неверно для semver// = default here would give "1.2.0" < "1.2.0-rc1" — wrong under semver

• cppreference — Comparisons (default comparisons, <=>)
• cppreference — <compare> (strong_ordering, weak_ordering, partial_ordering)
• WG21 P0515 — Consistent comparison