默认比较函数(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 个比较运算符。

基本示例 ​

cpp
#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_orderingstrong_ordering
包含 weak_ordering(无 partial_ordering)weak_ordering
包含 partial_orderingpartial_ordering
cpp
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== 就自动有 !=

编译器支持情况 ​

编译器最低支持版本
GCC10.0
Clang10.0
MSVC19.26 (VS 2019 16.6)

总结 ​

默认比较函数是 C++20 消除比较运算符样板代码的核心机制。通过 = default,编译器自动生成逐成员比较的实现,按成员声明顺序(先基类后成员)逐一比较,遇到不等就短路返回。最常用的写法是 auto operator<=>(const T&) const = default;,一行代码就得到全部 6 个比较运算符。如果只需要相等性比较,bool operator==(const T&) const = default; 就够了。默认比较还会自动推导 constexpr 和 noexcept,让编译期比较和异常安全都无需额外操心。对于绝大多数值类型来说,默认比较就是你需要的——简单、正确、零样板代码。