三向比较运算符推导规则 ​

面试考点 ​

C++20 的三向比较运算符(<=>,又叫宇宙飞船运算符)是面试高频考点。面试官考察你是否理解三种比较类别(strong_ordering、weak_ordering、partial_ordering)、= default 的自动生成规则、以及编译器如何从 <=> 重写其他比较运算符。

核心概念 ​

operator<=> 一次性定义了所有关系比较(<、>、<=、>=)。它的返回值不是 bool,而是一个比较类别对象。当你写 auto operator<=>(const T&) const = default; 时,编译器按成员声明顺序逐个比较,并自动推导返回类型。同时编译器还会自动生成 operator==。

三种比较类别 ​

类别含义典型类型
strong_ordering强序:相等的元素不可区分int, char, 枚举
weak_ordering弱序:等价的元素可能有区别大小写不敏感的字符串
partial_ordering偏序:某些元素无法比较double(NaN 不可比较)

基本示例 ​

cpp
#include <iostream>
#include <compare>
#include <string>
#include <vector>
#include <algorithm>
#include <cmath>

// ============================
// 示例1:= default 自动生成
// ============================

struct Version {
    int major;
    int minor;
    int patch;

    // 一行代码生成全部 6 个比较运算符
    auto operator<=>(const Version&) const = default;
    // 编译器自动:
    // 1. 推导返回类型为 strong_ordering(因为 int 是 strong_ordering)
    // 2. 按 major -> minor -> patch 顺序比较
    // 3. 同时生成 operator==
};

void default_demo() {
    Version v1{1, 2, 3};
    Version v2{1, 3, 0};
    Version v3{1, 2, 3};

    std::cout << (v1 < v2) << std::endl;   // 1(1.2.3 < 1.3.0)
    std::cout << (v1 == v3) << std::endl;  // 1
    std::cout << (v2 > v1) << std::endl;   // 1
    std::cout << (v1 != v2) << std::endl;  // 1

    // 可以直接排序
    std::vector<Version> versions = {{2,0,0}, {1,0,0}, {1,5,0}};
    std::sort(versions.begin(), versions.end());
    for (auto& v : versions) {
        std::cout << v.major << "." << v.minor << "." << v.patch << " ";
    }
    std::cout << std::endl;
}

// ============================
// 示例2:编译器重写规则
// ============================

/*
当编译器看到比较表达式时,会按以下规则重写:

  a < b   →  (a <=> b) < 0
  a > b   →  (a <=> b) > 0
  a <= b  →  (a <=> b) <= 0
  a >= b  →  (a <=> b) >= 0
  a == b  →  由 operator== 处理(不经过 <=>)
  a != b  →  !(a == b)

注意:== 和 != 不通过 <=> 重写,而是使用独立的 operator==。
这是因为 == 可以做短路优化(比如先比较长度)。
*/

struct Point {
    int x, y;
    auto operator<=>(const Point&) const = default;
    // 编译器同时默认生成 operator==
};

void rewrite_demo() {
    Point p1{1, 2}, p2{3, 4};

    // 编译器重写:
    // p1 < p2  →  (p1 <=> p2) < 0  →  先比 x,再比 y
    // p1 == p2 →  调用 operator==  →  x==x && y==y
    std::cout << (p1 < p2) << std::endl;   // 1
    std::cout << (p1 == p2) << std::endl;  // 0
}

// ============================
// 示例3:返回类型推导
// ============================

struct Mixed {
    int a;        // strong_ordering
    double b;     // partial_ordering(因为 NaN)

    auto operator<=>(const Mixed&) const = default;
    // 返回类型推导为 partial_ordering
    // 因为 partial_ordering 是最弱的公共类别
};

// 类别的强弱关系:
// strong_ordering > weak_ordering > partial_ordering
// 默认 <=> 的返回类型 = 所有成员比较类别中最弱的那个

void deduction_demo() {
    Mixed m1{1, 2.0}, m2{1, 3.0};
    auto result = m1 <=> m2;
    // result 的类型是 std::partial_ordering

    if (result < 0) {
        std::cout << "m1 < m2" << std::endl;
    }

    // NaN 导致 unordered
    Mixed m3{1, std::nan("")}, m4{1, 2.0};
    auto r = m3 <=> m4;
    if (r == std::partial_ordering::unordered) {
        std::cout << "m3 和 m4 无法比较(NaN)" << std::endl;
    }
}

// ============================
// 示例4:自定义 <=> 和 ==
// ============================

class CaseInsensitiveString {
    std::string data_;
public:
    CaseInsensitiveString(std::string s) : data_(std::move(s)) {}

    // 自定义 <=>:大小写不敏感,返回 weak_ordering
    // (因为 "Hello" 和 "hello" 等价但不相同)
    std::weak_ordering operator<=>(const CaseInsensitiveString& other) const {
        auto to_lower = [](char c) { return std::tolower(static_cast<unsigned char>(c)); };

        auto it1 = data_.begin();
        auto it2 = other.data_.begin();

        while (it1 != data_.end() && it2 != other.data_.end()) {
            char c1 = to_lower(*it1++);
            char c2 = to_lower(*it2++);
            if (c1 < c2) return std::weak_ordering::less;
            if (c1 > c2) return std::weak_ordering::greater;
        }

        if (data_.size() < other.data_.size()) return std::weak_ordering::less;
        if (data_.size() > other.data_.size()) return std::weak_ordering::greater;
        return std::weak_ordering::equivalent;
    }

    // 自定义 <=> 时必须手动定义 ==(不会自动从 <=> 推导)
    bool operator==(const CaseInsensitiveString& other) const {
        return (*this <=> other) == 0;
    }

    const std::string& str() const { return data_; }
};

void custom_demo() {
    CaseInsensitiveString a("Hello");
    CaseInsensitiveString b("hello");
    CaseInsensitiveString c("World");

    std::cout << (a == b) << std::endl;  // 1(大小写不敏感)
    std::cout << (a < c) << std::endl;   // 1
}

// ============================
// 示例5:继承中的 <=>
// ============================

struct Base {
    int x;
    auto operator<=>(const Base&) const = default;
};

struct Derived : Base {
    int y;
    auto operator<=>(const Derived&) const = default;
    // 先比较基类 Base 的成员,再比较 y
};

void inheritance_demo() {
    Derived d1{{1}, 2};
    Derived d2{{1}, 3};
    Derived d3{{2}, 1};

    std::cout << (d1 < d2) << std::endl;  // 1(x 相同,y: 2 < 3)
    std::cout << (d1 < d3) << std::endl;  // 1(x: 1 < 2)
}

// ============================
// 示例6:= default 的限制
// ============================

/*
= default 不适用的场景:
1. 需要跳过某些成员不参与比较
2. 需要自定义比较逻辑(如大小写不敏感)
3. 成员没有定义 <=> 运算符
4. 需要和不同类型比较

这些情况需要手写 <=> 和 ==。
*/

struct Employee {
    std::string name;
    int id;
    std::string department;  // 不参与比较

    // 只按 id 比较
    auto operator<=>(const Employee& other) const {
        return id <=> other.id;
    }

    bool operator==(const Employee& other) const {
        return id == other.id;
    }
};

void selective_demo() {
    Employee e1{"Alice", 1, "Engineering"};
    Employee e2{"Bob", 1, "Marketing"};

    // 同一个 id,视为相等(忽略 name 和 department)
    std::cout << (e1 == e2) << std::endl;  // 1
}

int main() {
    std::cout << "=== default ===" << std::endl;
    default_demo();

    std::cout << "\n=== 重写规则 ===" << std::endl;
    rewrite_demo();

    std::cout << "\n=== 返回类型推导 ===" << std::endl;
    deduction_demo();

    std::cout << "\n=== 自定义 ===" << std::endl;
    custom_demo();

    std::cout << "\n=== 继承 ===" << std::endl;
    inheritance_demo();

    std::cout << "\n=== 选择性比较 ===" << std::endl;
    selective_demo();

    return 0;
}

比较类别的层级关系 ​

转换方向说明
strong_ordering → weak_ordering隐式转换(强可以变弱)
weak_ordering → partial_ordering隐式转换
strong_ordering → partial_ordering隐式转换
反方向不能隐式转换

= default 的行为 ​

行为说明
比较顺序基类先于成员,成员按声明顺序
返回类型推导取所有成员类别中最弱的
operator==默认 <=> 时自动生成
短路== 先比较成员个数(如果适用)

常见问题 ​

为什么 == 不通过 <=> 重写?

性能原因。对于 string 这样的类型,== 可以先比较长度,长度不同直接返回 false,不需要逐字符比较。而 <=> 必须完整比较才能确定顺序。分离 == 和 <=> 允许各自做最优实现。

自定义 <=> 时是否自动生成 ==?

不会。只有 = default 的 <=> 才会同时默认生成 ==。手写 <=> 时必须同时手写 ==,否则 == 和 != 无法使用。

double 的 <=> 返回什么类型?

partial_ordering。因为 NaN 不等于任何值(包括自己),NaN 和任何值的比较都是 unordered,这只有 partial_ordering 能表示。

适用场景 ​

  • 值类型需要排序(= default 一行搞定)
  • 自定义排序逻辑(手写 <=>)
  • 大小写不敏感比较(返回 weak_ordering)
  • 涉及浮点数的比较(注意 partial_ordering)

注意事项 ​

  • = default 按成员声明顺序比较,改变成员顺序会改变比较行为
  • 手写 <=> 必须同时手写 ==
  • 包含 double 成员时返回类型会降级为 partial_ordering
  • <=> 需要 #include <compare>
  • C++20 之前的代码可能和重写规则冲突

总结 ​

C++20 的 <=> 运算符让比较变得简洁:一个 = default 生成全部六个比较运算符。返回类型从成员中自动推导(取最弱类别)。编译器将 <、>、<=、>= 重写为 <=> 的结果与 0 比较,但 == 和 != 使用独立的 operator==。面试中要能解释三种比较类别、= default 的推导规则、重写机制、以及为什么 == 和 <=> 分离。