C++20 Spaceship 操作符 (‘＜=＞‘)：现代 C++ 的比较利器

C++20 引入了一个革新性的特性：三向比较操作符，俗称 Spaceship 操作符 (<=>)。这一特性让程序员能够用一行代码实现高效、统一的对象比较逻辑，显著减少代码冗余，并提高了代码的可读性和开发效率。本文将从基础概念、使用场景、代码示例到性能优化，全面解析 Spaceship 操作符的强大功能。

1. 为什么需要 Spaceship 操作符?

在 C++20 之前，定义一个类的比较逻辑往往需要手动实现多个操作符（如 <, <=, >, >=, ==, !=）。这种方式既冗长又容易出错，代码维护也十分困难。而 Spaceship 操作符 (<=>) 的引入，通过统一接口自动生成这些比较操作符，使得实现和维护都变得简单高效。

1.1 传统方法示例

以下是使用传统方法为类 Point 定义比较操作符的示例：

struct Point {
  int x = 0;
  int y = 0;

  bool operator<(const Point& other) const {
    return (x < other.x) || (x == other.x && y < other.y);
  }
  bool operator<=(const Point& other) const { return !(other < *this); }
  bool operator>(const Point& other) const { return other < *this; }
  bool operator>=(const Point& other) const { return !(*this < other); }

  bool operator==(const Point& other) const {
    return x == other.x && y == other.y;
  }
  bool operator!=(const Point& other) const { return !(*this == other); }
};

可以看到，仅仅是实现一个简单的比较逻辑，就需要写大量冗余代码。

1.2 使用 Spaceship 操作符

使用 <=> 操作符，我们可以大幅简化上述代码：

#include <compare>

struct Point {
  int x = 0;
  int y = 0;

  auto operator<=>(const Point&) const = default; // 自动生成所有比较操作符
};

仅需一行代码, 便可生成所有比较操作符, 简洁且高效.

1.3 如何使用 Spaceship 操作符

spaceship 比较操作符的结果分为三个值

‘< 0’: 表示小于
‘== 0’: 表示相等
‘> 0’: 表示大于

int main() {
  Point p1{1, 2}, p2{2, 3};

  if (p1 < p2) {
    std::cout << "p1 is less than p2\n";
  }

  auto result = (p1 <=> p2);
  if (result < 0) {
    std::cout << "p1 is less than p2\n";
  } else if (result == 0) {
    std::cout << "p1 is equal to p2\n";
  } else {
    std::cout << "p1 is greater than p2\n";
  }
}

2. C++20 中的比较类型分类

Spaceship 操作符的核心在于返回一个标准化的比较结果，用于描述两个对象之间的相对关系。根据需求，C++20 提供了以下几种比较类型：

比较类型	特性	返回值	使用场景
`std::strong_equality`	严格相等	`equal` / `nonequal`	比如整数和字符串等完全一致比较
`std::weak_equality`	等价但不严格相等	`equivalent` / `nonequivalent`	浮点数近似比较，忽略大小写的比较
`std::strong_ordering`	严格排序	`less` / `equal` / `greater`	全序容器、排序算法
`std::weak_ordering`	弱排序，允许等价但不等同	`less` / `equivalent` / `greater`	近似比较，排序中允许等价处理
`std::partial_ordering`	偏序关系，允许无序	`less` / `greater` / `equivalent` / `unordered`	浮点数比较中的 NaN 处理

3. Spaceship 操作符的使用

3.1 默认生成

通过 = default, 编译器可以为类的所有成员自动生成 <=> 操作符及相关比较操作符.

示例:

#include <compare>
struct Point {
  int x, y;
  auto operator<=>(const Point&) const = default;
};

Point p1{1, 2}, p2{2, 3};
if (p1 < p2) std::cout << "p1 is less than p2\n";

3.2 自定义实现

用户可以根据需求手动定义 <=> 操作符:

#include <cmath>
#include <compare>
#include <iostream>
#include <limits>

struct CustomFloat {
  double value;

  // For floating point values, we must use partial_ordering
  std::partial_ordering operator<=>(const CustomFloat& other) const {
    // Handle NaN cases first
    if (std::isnan(value) || std::isnan(other.value)) {
      return std::partial_ordering::unordered;
    }
    // Now we can safely compare the values
    if (value < other.value) return std::partial_ordering::less;
    if (value > other.value) return std::partial_ordering::greater;
    return std::partial_ordering::equivalent;
  }

  // We need to explicitly define operator== for partial ordering
  bool operator==(const CustomFloat& other) const {
    // First check for NaN
    if (std::isnan(value) || std::isnan(other.value)) {
      return false;  // NaN is never equal to anything, including itself
    }
    return value == other.value;
  }
};

int main() {
  // Regular number comparisons
  CustomFloat a{0.1}, b{0.10000001};
  CustomFloat c{0.1}, d{0.1};

  // NaN cases
  CustomFloat nan1{std::numeric_limits<double>::quiet_NaN()};
  CustomFloat nan2{std::numeric_limits<double>::quiet_NaN()};

  std::cout << std::boolalpha;
  std::cout << "Testing regular numbers:\n";
  if (auto cmp = a <=> b; cmp == std::partial_ordering::equivalent) {
    std::cout << "0.1 is equivalent to 0.10000001\n";
  } else if (cmp == std::partial_ordering::less) {
    std::cout << "0.1 is less than 0.10000001\n";
  } else if (cmp == std::partial_ordering::greater) {
    std::cout << "0.1 is greater than 0.10000001\n";
  }

  std::cout << "\nTesting equal numbers:\n";
  if (auto cmp = c <=> d; cmp == std::partial_ordering::equivalent) {
    std::cout << "0.1 is equivalent to 0.1\n";
  }

  std::cout << "\nTesting NaN cases:\n";
  if (auto cmp = nan1 <=> a; cmp == std::partial_ordering::unordered) {
    std::cout << "NaN compared with 0.1 is unordered\n";
  }

  if (auto cmp = nan1 <=> nan2; cmp == std::partial_ordering::unordered) {
    std::cout << "NaN compared with NaN is unordered\n";
  }

  // Using regular comparison operators (they should work automatically)
  std::cout << "\nTesting regular comparison operators:\n";
  std::cout << "0.1 < 0.10000001: " << (a < b) << '\n';
  std::cout << "0.1 == 0.1: " << (c == d) << '\n';
  std::cout << "NaN == NaN: " << (nan1 == nan2) << '\n';

  return 0;
}

5. 与传统比较操作符的兼容性问题

5.1 调用 `a < b` 时方法的解析顺序

为了编译:

a < b

编译器会依次查找如下方法:

a.operator<(b)  // calling member operator<= for a
operator<(a, b) // calling a free-standing operator<= for a and b

a.operator<=>(b) <= 0 // calling member operator<=> for a
operator<=>(a, b) <= 0 // calling a free-standing operator<=> for a and b

0 < b.operator<=>(a) // calling member operator<=> for y

5.2 调用 `a == b` 时方法的解析顺序

为了编译

a != b

会依次查找:

a.operator!=(b) // calling member operator!= for a
operator!=(a, b) // calling a free-standing operator!= for a and b

!a.operator==(b) // calling member operator== for a
!operator==(a, b) // calling a free-standing operator== for a and b

!a.operator==(b) // calling member operator== generated by operator<=> for a
!b.operator==(a) // calling member operator== generated by operator<=> for b

4. 实际应用场景

排序容器: 为 std::set 或 std::map 定义自定义排序规则.
浮点数比较: 使用 std::partial_ordering 处理 NaN.
简化大型类比较: 减少多字段对象比较的代码复杂度.

5. 注意事项

默认生成的条件:
- 类的所有成员变量都支持 <=> 操作.
返回值类型选择:
- 根据场景返回适合的比较类型(如 std::strong_ordering).
逻辑清晰性:
- 手动实现 <=> 时, 确保覆盖所有可能的比较情况.

6. 总结

Spaceship 操作符是 C++20 现代化的重要一步, 它通过统一的接口大大简化了对象的比较逻辑, 使代码更简洁, 更高效. 在日常开发中, 掌握并合理使用 <=> 操作符, 将帮助你写出更加优雅和可靠的代码.