这个 C++20 新特性让对象比较变得如此优雅-51CTO.COM

嘿，C++星际旅行者！还记得那些写到手抽筋的比较运算符吗？<、>、<=、>=、==、!= —— 写多了感觉自己在跳芭蕾舞！但是等等，C++20 给我们带来了一个超级酷炫的新玩具 —— 三路比较运算符！因为它长得像一艘可爱的小太空船，所以大家都亲切地叫它"太空船运算符"：<=>

为什么我们需要这艘太空船？

想象一下，你正在开发一个电商网站，需要对商品进行价格排序。在传统的 C++世界里，你需要写一大堆比较运算符，就像这样：

class Product {
    double price;      // 💰 商品价格
    int stock;         // 📦 库存数量
    string name;       // 🏷️ 商品名称
public:
    // 看看这些重复的代码，像不像复制粘贴的艺术？😅
    bool operator<(const Product& other) const;   // 比这个贵吗？
    bool operator>(const Product& other) const;   // 比这个便宜吗？
    bool operator<=(const Product& other) const;  // 不比这个贵吧？
    bool operator>=(const Product& other) const;  // 不比这个便宜吧？
    bool operator==(const Product& other) const;  // 价格一样？
    bool operator!=(const Product& other) const;  // 价格不一样？
};1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.

哇！这代码写得我头晕眼花！不仅要写六个函数，还要确保它们之间的逻辑一致性。一不小心就会把 < 和 > 写反，让你的打折商品比原价还贵... 这简直就是在玩杂耍！

太空船来了！

有了 C++20 的太空船运算符，你只需要写一个运算符：

class Product {
    double price;      // 💰 商品价格
    int stock;         // 📦 库存数量
    string name;       // 🏷️ 商品名称
public:
    auto operator<=>(const Product& other) const = default; // 魔法！✨
};1.
2.
3.
4.
5.
6.
7.

就这样！一行代码替代了六个运算符！就像有了一根魔法棒，帮你完成所有工作！

太空船的驾驶指南

听好啦，太空船不是普通的飞行器，它有三种超酷的飞行模式！就像是游戏里的三种不同难度等级，每种都有它的独特用途！

首先是 std::strong_ordering —— 这是最严格的模式！就像比较商品价格一样，10.99 就是比 11.99 便宜，不讲价！这种比较明确得不能再明确了，不会有任何模棱两可。

然后是 std::weak_ordering —— 这个就像是咱们的"差不多先生"了！比如说字符串 "Hello" 和 "hello"，虽然大小写不同，但其实说的是同一个词。它们是等价的，但又不是完全一模一样。

最后是 std::partial_ordering —— 这个最随性了！有时候甚至会说"抱歉，这俩没法比较"。就像是在餐厅比较"辣子鸡"和"冰淇淋"，谁更好吃？这个问题本身就很哲学...

来看看怎么驾驶这艘太空船：

// 太空船的航行日志 📝
if (price1 <=> price2 < 0) {
    std::cout << "哇！发现特价商品！赶紧抢购！🏃♂️" << std::endl;
} else if (price1 <=> price2 > 0) {
    std::cout << "emmm...这个有点小贵啊！💸" << std::endl;
} else {
    std::cout << "价格一样？！难道是平行宇宙的同款？🌌" << std::endl;
}1.
2.
3.
4.
5.
6.
7.
8.

看到了吗？用起来比玩游戏还简单！而且不会迷路，因为编译器就是你的星际导航仪！

太空船的三种超能力

让我们来揭秘太空船运算符的三种神奇超能力！就像是从漫威电影里走出来的超级英雄一样酷炫！

1.钢铁侠模式：强序比较

这是最严谨的比较模式，就像钢铁侠的装甲一样精确！想象你在淘宝买东西：

// 太空船的航行日志 📝
if (price1 <=> price2 < 0) {
    std::cout << "哇！发现特价商品！赶紧抢购！🏃♂️" << std::endl;
} else if (price1 <=> price2 > 0) {
    std::cout << "emmm...这个有点小贵啊！💸" << std::endl;
} else {
    std::cout << "价格一样？！难道是平行宇宙的同款？🌌" << std::endl;
}1.
2.
3.
4.
5.
6.
7.
8.

这就像物理定律一样严格，不讲情面！1分钱也是钱，一个铜板都不能马虎！🪙

2.蜘蛛侠模式：弱序比较

这种比较超级灵活，就像蜘蛛侠的蛛丝一样！有时候我们并不在意完全相同，差不多就行：

class LazyText {  // 懒人文本类
    std::string text;
public:
    std::weak_ordering operator<=>(const LazyText& other) const {
        // 不管大小写，都是一家人！
        std::string me = text;      // 我写的
        std::string you = other.text;  // 你写的
        // 把所有字母都变小写，像把超级英雄换上便装
        std::transform(me.begin(), me.end(), me.begin(), ::tolower);
        std::transform(you.begin(), you.end(), you.begin(), ::tolower);
        
        if (me < you) return std::weak_ordering::less;        // 我比你小
        if (me > you) return std::weak_ordering::greater;     // 我比你大
        return std::weak_ordering::equivalent;  // 我们是一家人！
    }
};

LazyText msg1{"Hello World"};   // 我是正经人
LazyText msg2{"hElLo wOrLd"};   // 我是个顽皮鬼
// 虽然写法不同，但都在说"你好，世界"！🌍1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.

3.浩克模式：偏序比较

这是最狂野的比较模式，就像浩克一样不按常理出牌！有时候甚至会说"不好意思，这个真没法比"：

class QuantumMood {  // 量子心情类 🌈
    double happiness;  // 心情指数
public:
    std::partial_ordering operator<=>(const QuantumMood& other) const {
        if (std::isnan(happiness) || std::isnan(other.happiness))
            return std::partial_ordering::unordered;  // 心情无法比较！
        if (happiness < other.happiness) 
            return std::partial_ordering::less;       // 我不太开心
        if (happiness > other.happiness) 
            return std::partial_ordering::greater;    // 我超开心
        return std::partial_ordering::equivalent;     // 心情一样！
    }
};

QuantumMood monday{-999.99};    // 周一的心情 😫
QuantumMood friday{NAN};        // 周五的心情已经无法用数字衡量了！🎉
// 这两种心情根本没法比，就像问浩克"你开心吗？"一样！1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.

太空船的隐藏技能

太空船运算符还有一些很酷的特性：

(1) 自动生成其他比较运算符

class Score {
    int value;
public:
    auto operator<=>(const Score&) const = default;
    // 编译器会自动为你生成 ==、!=、<、<=、>、>= 
};1.
2.
3.
4.
5.
6.

(2) 支持不同类型之间的比较

class Minutes {
    int mins;
public:
    auto operator<=>(const Hours& hours) const {
        return mins <=> (hours.value * 60);  // 自动类型转换！
    }
};1.
2.
3.
4.
5.
6.
7.

实用小贴士

(1) 默认实现的魔法

struct Point {
    int x, y;
    auto operator<=>(const Point&) const = default;  // 自动按成员声明顺序比较
};1.
2.
3.
4.

(2) 自定义比较逻辑

class Student {
    std::string name;
    int score;
public:
    auto operator<=>(const Student& other) const {
        // 先按分数排序，分数相同再按姓名排序
        if (auto cmp = score <=> other.score; cmp != 0)
            return cmp;
        return name <=> other.name;
    }
};1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.

性能小课堂

使用太空船运算符不仅代码更简洁，性能也可能更好！因为它只需要进行一次比较，就能得到所有需要的信息：

// 旧方式：可能需要多次比较
if (a < b) { /* ... */ }
if (a > b) { /* ... */ }  // 重复比较！

// 新方式：一次比较搞定所有！
auto cmp = a <=> b;
if (cmp < 0) { /* a < b */ }
if (cmp > 0) { /* a > b */ }1.
2.
3.
4.
5.
6.
7.
8.

结束语

太空船运算符就像是给你的代码装上了一个超级加速器，让比较操作变得既简单又高效！记住，好的代码就像优秀的太空船 —— 简洁、高效、可靠！现在，是时候让你的代码起飞了！