三向比较运算符推导规则
面试考点
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 不可比较) |
基本示例
#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 的推导规则、重写机制、以及为什么 == 和 <=> 分离。