默认比较函数(Defaulted Comparisons)
什么是默认比较函数
C++20 允许你用 = default 来声明比较运算符,让编译器自动生成逐成员比较的实现。这和构造函数、赋值运算符的 = default 思路一样——当默认行为(按成员逐一比较)就是你想要的行为时,让编译器代劳,避免手写重复代码。
C++20 之前,即使你的类只是几个简单成员的组合,想支持比较操作也得自己写 operator==、operator< 等函数。C++20 之后,一行 = default 就能搞定。
两组比较运算符
C++20 把 6 个比较运算符分成两组,每组有一个"主运算符":
| 组别 | 主运算符 | 派生运算符 | 关系 |
|---|---|---|---|
| 相等性比较 | == | != | != 是 == 的取反 |
| 关系比较 | <=> | <、>、<=、>= | 由 <=> 的结果推导 |
规则很简单:
- 定义或默认
operator==,编译器自动生成operator!= - 定义或默认
operator<=>,编译器自动生成<、>、<=、>= - 默认
operator<=>时,如果没有显式声明operator==,编译器还会隐式默认一个operator==
所以,最省事的写法是只写一行 auto operator<=>(const T&) const = default;,就能得到全部 6 个比较运算符。
基本示例
#include <iostream>
#include <compare>
#include <string>
#include <set>
#include <unordered_set>
#include <vector>
#include <algorithm>
// ============================
// 示例1:默认全部比较运算符(最简写法)
// ============================
struct Point {
int x;
int y;
// 一行搞定 6 个比较运算符
// 编译器按成员声明顺序逐一比较:先 x,再 y
auto operator<=>(const Point&) const = default;
// 这一行同时隐式默认了 operator==
};
void full_default_demo() {
Point p1{1, 2}, p2{1, 3}, p3{1, 2};
std::cout << std::boolalpha;
std::cout << "p1 == p3: " << (p1 == p3) << std::endl; // true
std::cout << "p1 != p2: " << (p1 != p2) << std::endl; // true
std::cout << "p1 < p2: " << (p1 < p2) << std::endl; // true(x 相等,比较 y)
std::cout << "p2 > p1: " << (p2 > p1) << std::endl; // true
// 可以直接用于 set
std::set<Point> s{p1, p2, p3};
std::cout << "set 大小: " << s.size() << std::endl; // 2
// 可以直接排序
std::vector<Point> vec{p2, p1, p3};
std::sort(vec.begin(), vec.end());
}
// ============================
// 示例2:只默认相等性比较
// ============================
struct Color {
int r, g, b;
// 只默认 operator==,自动得到 operator!=
// 但不支持 <、>、<=、>=
bool operator==(const Color&) const = default;
};
void equality_only_demo() {
Color c1{255, 0, 0}, c2{0, 255, 0}, c3{255, 0, 0};
std::cout << "c1 == c3: " << (c1 == c3) << std::endl; // true
std::cout << "c1 != c2: " << (c1 != c2) << std::endl; // true
// 以下会编译错误(没有定义关系比较):
// std::cout << (c1 < c2) << std::endl;
}
// ============================
// 示例3:带继承的默认比较
// ============================
struct Base {
int id;
auto operator<=>(const Base&) const = default;
};
struct Derived : Base {
std::string name;
// 编译器先比较基类部分(id),再比较派生类成员(name)
auto operator<=>(const Derived&) const = default;
};
void inheritance_demo() {
Derived d1{{1}, "Alice"};
Derived d2{{1}, "Bob"};
Derived d3{{2}, "Alice"};
std::cout << "d1 < d2: " << (d1 < d2) << std::endl; // true(id 相等,比较 name)
std::cout << "d1 < d3: " << (d1 < d3) << std::endl; // true(id 1 < 2)
std::cout << "d1 == d1: " << (d1 == d1) << std::endl; // true
}
// ============================
// 示例4:成员函数 vs 友元函数的默认比较
// ============================
struct MemberStyle {
int value;
// 成员函数形式
bool operator==(const MemberStyle&) const = default;
auto operator<=>(const MemberStyle&) const = default;
};
struct FriendStyle {
int value;
// 友元函数形式(支持隐式转换的两个操作数)
friend bool operator==(const FriendStyle&, const FriendStyle&) = default;
friend auto operator<=>(const FriendStyle&, const FriendStyle&) = default;
};
// ============================
// 示例5:默认比较的 constexpr 和 noexcept
// ============================
struct SimpleData {
int a;
double b;
// 默认比较自动推导 constexpr 和 noexcept
auto operator<=>(const SimpleData&) const = default;
};
void constexpr_demo() {
// 默认比较是 constexpr 的(如果所有成员的比较也是 constexpr)
constexpr SimpleData s1{1, 2.0}, s2{1, 3.0};
static_assert(s1 < s2); // 编译期比较
static_assert(s1 == s1); // 编译期比较
static_assert(s1 != s2); // 编译期比较
std::cout << "constexpr 默认比较测试通过" << std::endl;
}
int main() {
std::cout << "=== 全部默认 ===" << std::endl;
full_default_demo();
std::cout << "\n=== 只默认 == ===" << std::endl;
equality_only_demo();
std::cout << "\n=== 继承 ===" << std::endl;
inheritance_demo();
std::cout << "\n=== constexpr ===" << std::endl;
constexpr_demo();
return 0;
}默认比较的生成规则
编译器生成的默认比较按以下顺序逐一比较"子对象":
- 基类(按声明顺序,从左到右)
- 非静态数据成员(按声明顺序)
- 如果成员是数组,展开为元素序列逐一比较
如果某个子对象的比较返回"不相等"(对 ==)或"非零"(对 <=>),立即短路返回,不再继续比较后续成员。
默认比较的返回类型推导
当 operator<=> 的返回类型写成 auto 时,编译器会根据所有成员的 <=> 返回类型推导出最终的比较类别:
| 所有成员的比较类别 | 推导结果 |
|---|---|
全是 strong_ordering | strong_ordering |
包含 weak_ordering(无 partial_ordering) | weak_ordering |
包含 partial_ordering | partial_ordering |
struct AllInt {
int a, b, c;
auto operator<=>(const AllInt&) const = default;
// 推导为 strong_ordering(int 的 <=> 是 strong_ordering)
};
struct HasDouble {
int a;
double b; // double 的 <=> 是 partial_ordering
auto operator<=>(const HasDouble&) const = default;
// 推导为 partial_ordering
};C++20 之前与之后的对比
| 场景 | C++20 之前 | C++20 |
|---|---|---|
| 6 个比较运算符 | 手写 6 个函数 | auto operator<=>(const T&) const = default; |
| 只要 == 和 != | 手写 2 个函数 | bool operator==(const T&) const = default; |
| 带继承的比较 | 手动调用基类比较 | 编译器自动处理 |
| constexpr 比较 | 每个函数加 constexpr | 自动推导 |
| noexcept 比较 | 每个函数加 noexcept | 自动推导 |
适用场景
- 值类型(坐标、颜色、版本号、日期等)的逐成员比较
- 需要放入
std::set/std::map的键类型 - 需要排序或去重的数据类型
- 单元测试中需要断言两个对象相等
- 任何"默认的逐成员比较就够用"的场景
常见问题
默认 <=> 和默认 == 可以分开写吗?
可以。如果你只需要相等性比较,只写 bool operator==(const T&) const = default; 就行。如果你只需要关系比较但想自定义相等性判断,可以分开写。
哪些成员类型不支持默认比较?
如果某个成员类型本身不支持对应的比较运算符,默认比较就无法生成。比如 std::function 没有 operator==,包含它的类不能默认 ==。编译器会给出明确的错误信息。
默认比较可以是虚函数吗?
不能。默认比较运算符不能声明为 virtual。
默认比较和手写比较可以混用吗?
可以。你可以默认 <=>,然后手写 ==(比如对 std::string 成员先比较长度来优化)。也可以手写 <=>,然后默认 ==。
unordered_set/unordered_map 需要什么?
它们需要 operator== 和 std::hash 特化。默认比较只生成 operator==,std::hash 还是需要你自己写。
注意事项
auto operator<=>(const T&) const = default;会同时隐式默认operator==(如果没有显式声明)- 自定义
operator<=>时,operator==不会自动生成,需要单独声明 - 默认比较的成员函数必须是
const的 - 默认比较按声明顺序比较成员,所以成员的声明顺序会影响比较结果
- 默认比较自动推导
constexpr和noexcept - 包含不可比较成员的类不能使用默认比较
operator!=不需要单独声明——有了operator==就自动有!=
编译器支持情况
| 编译器 | 最低支持版本 |
|---|---|
| GCC | 10.0 |
| Clang | 10.0 |
| MSVC | 19.26 (VS 2019 16.6) |
总结
默认比较函数是 C++20 消除比较运算符样板代码的核心机制。通过 = default,编译器自动生成逐成员比较的实现,按成员声明顺序(先基类后成员)逐一比较,遇到不等就短路返回。最常用的写法是 auto operator<=>(const T&) const = default;,一行代码就得到全部 6 个比较运算符。如果只需要相等性比较,bool operator==(const T&) const = default; 就够了。默认比较还会自动推导 constexpr 和 noexcept,让编译期比较和异常安全都无需额外操心。对于绝大多数值类型来说,默认比较就是你需要的——简单、正确、零样板代码。